This guide walks through automating a Go project's build, handling private repository credentials, and deploying the compiled binary to a remote server using a Jenkins pipeline, covering project structure, build steps, credential management, and a complete pipeline script.
The article emphasizes that a CI/CD pipeline must be the exclusive route for deploying immutable artifacts to production, warning against direct local deployments, highlighting risks of lost traceability, and urging strict network-level controls to ensure only the pipeline can release code.
This article presents the design, implementation, and optimization of a deep‑learning‑based ranking system for NetEase News, covering pipeline architecture, feature‑processing enhancements, custom TensorFlow operators, and modular model frameworks such as DCN and DIEN to improve recommendation performance.
This article explains how to build a real‑time game leaderboard using Redis sorted sets, covering ranking categories, composite scoring formulas, dynamic updates, efficient data retrieval with pipelines, and provides a complete PHP class implementation.
This guide explains why Jenkins Shared Libraries are essential for reducing repetitive pipeline code in micro‑service projects, walks through creating and configuring a shared library, and demonstrates advanced usage with parameters, multi‑branch pipelines, and environment variable handling.
This article explains how to implement a real‑time ranking system for a mobile tank game using Redis sorted sets, covering ranking categories, composite scoring formulas, dynamic updates, efficient data retrieval with pipelines, and a complete PHP class example.
Learn how to configure a Jenkins single‑branch pipeline to accept a branch name as a parameter, enabling dynamic code checkout by setting up a String parameter, using ${BranchName} in the pipeline script, and handling potential Lightweight checkout errors.
The article explains why artifacts should be built only once and treated as immutable, using containers as the ideal vehicle, and warns against the anti‑pattern of rebuilding from source code at each pipeline stage, which slows pipelines and creates inconsistent production releases.
The article explains why comprehensive artifact management and strict version control of all application‑related files—including source code, scripts, configurations, and database assets—are essential for reliable DevOps pipelines, and outlines practical guidelines and common anti‑patterns to avoid.
This article explains the origins of DevOps, its evolution from agile practices, its deep integration with containers and Kubernetes, and demonstrates a complete CI/CD pipeline using tools like Jenkins, Gogs, Nexus, and SonarQube to achieve automated, end‑to‑end software delivery.
This guide introduces Tekton, a cloud-native CI/CD framework, explains its benefits, components, installation steps, core concepts, and provides a complete example that defines tasks, pipelines, Docker image building, and execution on a Kubernetes cluster.
This tutorial explains how to create a Jenkins Pipeline that builds a Go application, packages it into a Docker image, pushes it to a private Harbor registry, and deploys it to a Kubernetes cluster using Helm, covering node labeling, pod templates, credentials, and optional rollback.
This article introduces Jenkins shared libraries, explaining their structure, how to create a library with Groovy classes, configure it in Jenkins, and use it in pipelines, including sample code for colored log output and step-by-step setup instructions for DevOps practitioners.
This article explains how Ctrip’s NFES framework adopts a GitDev CI/CD pipeline—detailing the Install, Verify, and SonarAndImage stages, their constituent steps, and the .gitlab-ci.yml configuration—to streamline web development, improve code quality, and accelerate delivery of front‑end projects.
This article provides a detailed tutorial on Jenkins Pipeline environment variables, covering how to list, read, set, override, store boolean values, and capture shell command output within pipelines, complete with practical code examples and best‑practice tips.
This article details China Life Property & Casualty Insurance's agricultural insurance claims system achieving Level 3 DevOps continuous‑delivery assessment, shares insights from an interview with the R&D center head on motivations, implementation, metrics, challenges, and future plans, and explains the DevOps maturity model and pipeline architecture.
This guide walks you through installing the DingTalk and Build User Vars plugins, configuring a DingTalk robot, creating a Groovy shared library, and integrating it into a Jenkins pipeline to automatically push build notifications and change logs to DingTalk.
This article explains the fundamentals of Node.js streams, including basic concepts, stream types, pipe and pipeline usage, handling backpressure, and demonstrates how async iterators can simplify stream processing with detailed code examples and visual animations.
This article details the design and evolution of the ReX Dev front‑end engineering platform used by Alibaba's Hema, covering its layered architecture, robust metadata model, flexible pipeline engine, SPI‑based service extensions, LowCode/ProCode interconversion, and practical guidelines for building a high‑productivity, extensible development platform.
This article explains what a CI/CD pipeline is, why it is essential for DevOps, outlines its standard stages, discusses implementation steps and tool‑selection principles, highlights current cloud‑native trends, and warns against common anti‑patterns that can hinder continuous delivery.
This article introduces the Jenkins Deploy Dashboard plugin, explains how to visualize deployment status across environments, and provides step‑by‑step instructions with code examples for adding deployments to the dashboard, creating the view, and adding deployment buttons to pipelines.
This guide compiles 21 practical Redis usage guidelines covering key naming conventions, value size limits, expiration strategies, batch operations, risky commands, distributed lock patterns, cache consistency, capacity planning, and common pitfalls like cache penetration, snowball, and hot‑key issues, helping developers and operators build reliable, high‑performance Redis deployments.
This article explains how Spinnaker enables continuous delivery on Kubernetes by describing its role, architecture, pipeline design, workflow steps, and best practices for deploying applications across multiple cloud providers in a cloud‑native environment.
This article explains how Spark transforms a logical execution graph into a physical job by partitioning stages, applying pipeline concepts, and generating tasks, while illustrating the process with detailed code examples and the internal workflow of job submission.
This article explains how the invention of assembly‑line manufacturing parallels modern CPU pipelines, why processing an ordered array can be nearly ten times faster than an unordered one, and shows a practical bit‑wise optimization to eliminate costly if‑statements for high‑performance code.
This article presents a comprehensive study on generating recruitment job titles by combining a rule‑based pipeline with advanced seq2seq models—including BiLSTM‑Attention, Pointer‑Generator, and a Field‑Gate Dual‑Attention architecture—demonstrating significant performance gains on real‑world hiring data.
This guide walks you through installing GitLab Runner via Docker, configuring its types and states, registering it with a GitLab instance, and creating a simple .gitlab-ci.yml pipeline to verify end‑to‑end CI/CD functionality.
This article introduces Pipcook, a machine‑learning framework designed for front‑end developers, explains its architecture and integration with TensorFlow.js, Boa, and Node.js, and discusses how it lowers the barrier to building intelligent front‑end applications through pipelines, plugins, and cloud‑native deployment.
This guide explains GitLab CI/CD concepts, configuration files, runner setup, pipeline stages, and advanced features like Auto DevOps, providing step‑by‑step examples and code snippets for practical implementation.
This tutorial walks you through setting up Jenkins with Docker, exploring built‑in and custom pipeline environment variables, overriding rules, Boolean handling, and capturing shell command output, providing practical code examples for each step.
This article explains GitLab CI/CD fundamentals, how continuous integration, delivery, and deployment work, shows how to configure .gitlab-ci.yml files, set up runners, visualize pipelines, and leverage Auto DevOps for automated build‑test‑deploy cycles.
This guide explains how to use Jenkins pipeline shared libraries to create a flexible DingTalk robot notifier, covering message types, template design, Groovy implementation, and integration into pipeline post‑steps for automated build alerts.
This article explains how DevOps principles are adapted for mobile app delivery, detailing the unique challenges of fragmented build environments, device diversity, longer release cycles, and massive scale, and describes Alibaba Cloud’s EMAS Mobile DevOps solution, its architecture, security, scalability, and future roadmap.
Java 8’s Stream API builds a lazy pipeline where each intermediate operation is recorded as a stage and only a terminal operation triggers a single-pass execution, using internal classes like ReferencePipeline, Slink, and Sink to efficiently combine stateless, stateful, and short‑circuiting operations.
This article provides a comprehensive guide to advanced Redis operations, covering pipeline usage, transaction handling, publish/subscribe mechanisms, key migration techniques, custom command implementation with Jedis, and efficient key scanning methods, complete with code examples and performance comparisons.
This article explains how to set up a Laravel route and controller that leverages the Pipeline class to pass a request through three custom pipe classes—LeftWords, RightWords, and BothSidesWords—modifying the input and storing the result as a new user record.
This article explains the internal mechanics of Java Stream’s pipeline, covering how operations are recorded as stages, how intermediate and terminal operations are composed via the Sink interface, and why the implementation achieves lazy evaluation and efficient parallel execution.
The Continuous Delivery Architect (CDA) course teaches DevOps pipeline design, implementation, and management, covering continuous integration, delivery, testing, deployment, monitoring, security, and the cultural practices needed to boost speed, reduce risk, and earn a certification.
This article provides a comprehensive overview of GitLab CI/CD, explaining continuous integration, delivery, and deployment concepts, detailing the .gitlab-ci.yml configuration, pipeline workflow, runner setup, Auto DevOps features, and includes practical code examples for building, testing, and deploying applications.
This guide explains what Tekton is, why a Kubernetes‑native CI/CD solution is advantageous, and provides step‑by‑step instructions—including required images, YAML manifests, and command‑line examples—to install Tekton, define tasks and pipelines, run a Go test pipeline, and troubleshoot common issues.
This guide walks you through creating a dedicated GitLab account for Jenkins, generating and registering SSH keys, installing required GitLab plugins, configuring credentials and tokens, writing a Jenkins pipeline script, and automating deployment with password‑less SSH between servers.
This tutorial walks you through using Pipcook to train an object‑detection model that automatically identifies and locates front‑end UI components in screenshots, covering data preparation in Pascal VOC format, pipeline configuration, model training, and inference with sample code.
This guide walks you through preparing data, configuring a Pipcook pipeline, training a TensorFlow MobileNet model, and using the resulting model to automatically recognize frontend UI components such as buttons, charts, and tables from screenshots.
This article introduces Pipcook, a machine‑learning framework designed for front‑end developers, explains its flexible pipeline architecture, showcases the Boa bridge that lets JavaScript call Python libraries, and outlines the upcoming PipApp concept for building end‑to‑end AI applications.
This article explains how Java Stream pipelines are built and executed, covering operation recording, the role of stages and sinks, differences between intermediate and terminal operations, and how the library achieves efficient single-pass processing while avoiding common pitfalls.
This guide walks through installing Jenkins Blue Ocean via Docker, setting up the Jenkins home directory, launching the server, and creating pipelines using both the classic Jenkins UI with a declarative Jenkinsfile and the visual Blue Ocean plugin, covering configuration, triggers, stages, and artifact handling.
This guide details a complete GitLab‑based CI/CD workflow—from issue creation and feature‑branch handling through build, test, code‑analysis, Docker image creation, and Kubernetes deployment—illustrating pipeline configuration, variable management, and trigger rules for reliable end‑to‑end project delivery.
This article explains two practical methods—using a custom linter.sh script that calls Jenkins's REST API and employing the Jenkins Pipeline Linter Connector VS Code extension—to validate declarative pipeline syntax before committing, reducing repeated build failures caused by syntax errors.
This article provides a step‑by‑step guide on installing Jenkins Blue Ocean via Docker, creating pipelines using both the classic UI and the Blue Ocean visual plugin, and configuring pipeline stages, triggers, and environment variables with example Groovy scripts.
This presentation walks through a step‑by‑step approach that blends real‑world business needs, design patterns, and Jenkins features to demonstrate how a shared‑library‑based pipeline engine can support large‑scale, complex CI/CD scenarios, from native solutions to structured atomic units and dynamic execution refactoring.
This article provides a comprehensive introduction to Apache Beam, covering its unified batch‑and‑stream processing architecture, programming model, workflow patterns, Lambda and Kappa architectures, the characteristics of PCollection, pipeline construction, core transforms, I/O handling, and includes practical code examples.
This tutorial explains how to use GitLab CI's only/except parameters and the newer rules syntax—including if, changes, exists, and allow_failure clauses—to control job execution, configure branch restrictions, and define workflow-level pipeline creation, illustrated with comprehensive YAML examples.
This article explains how WebRTC builds the video processing pipeline by detailing the capture module, internal data flow, VideoTrack construction, rendering, and encoder integration, and it outlines the key API calls such as AddTrack, CreateOffer, and SetLocalDescription that establish the end‑to‑end video stream.
This tutorial explains how to use GitLab CI keywords such as tags, allow_failure, when, manual, delayed, retry, timeout, and parallel to control runner selection, job execution conditions, failure handling, scheduling, retry policies, time limits, and concurrent job instances within CI/CD pipelines.
This guide explains how to configure GitLab CI/CD pipelines using the .gitlab-ci.yml file, covering job definitions, script syntax, before_script and after_script hooks, stage ordering, .pre/.post stages, and variable scopes with practical YAML examples.
This guide explains how to periodically synchronize Bitbucket master branches to GitHub repositories using a Jenkins pipeline, detailing branch policies, a simplified workflow for feature and bugfix branches, and a reusable Jenkinsfile that leverages parameterized builds to control repository syncing.
Learn how to dramatically boost Redis speed by shortening key/value sizes, enabling lazy free, setting expirations, disabling costly commands, using slowlog, pipelines, avoiding mass expirations, optimizing clients, limiting memory, running on physical servers, tweaking persistence, disabling THP, and adopting distributed architectures.
This article describes how to build a CI/CD pipeline using TFS for source control and Jenkins for automation on a Red Hat OpenShift‑based PaaS, covering code management, automated builds, testing, container image creation, deployment, and the necessary Jenkins and TFS configurations.
Learn how to dramatically improve Redis performance by shortening key-value sizes, enabling lazy free, setting expirations, disabling costly commands, using slowlog, leveraging pipeline, preventing mass expirations, optimizing client connections, limiting memory, running on physical servers, configuring persistence, disabling THP, and adopting distributed architectures.
This article provides a comprehensive guide to Redis, covering atomic transactions, command pipelining, publish/subscribe messaging, data replication, high‑availability with Sentinel, and the distributed architecture of Redis Cluster, complete with code examples and configuration steps.
This tutorial explains how to set up Docker‑in‑Docker for Jenkins, mount the Docker socket, run containers as root, and create multi‑stage pipelines that use different Docker images for Maven and Node builds, including troubleshooting tips.
This article explains why and how to adopt the open‑source Cppcheck tool for C/C++ static analysis, covering installation on Linux, building from source, command‑line usage, Jenkins plugin integration, pipeline scripting, and report visualization to prevent new warnings from entering the codebase.
This article explains what Jenkins and pipelines are, then guides you through installing Docker, running a Jenkins container, retrieving the initial admin password, and completing the Jenkins setup via the web interface, including plugin installation and user creation.
This article presents a complete Jenkinsfile that defines choice parameters for selecting an environment and dynamically populates a server list using Groovy scripts, then demonstrates a simple pipeline stage that validates and echoes the chosen values, aborting the build if validation fails.
This guide explains how to use Jenkinsfile Runner to execute Jenkins pipelines locally via the command line or Docker, covering prerequisite downloads, building the runner, command‑line options, a sample Jenkinsfile, and tips on plugin management for efficient testing.
This guide explains how to install and configure the Jenkins Active Choices plugin to create dynamic, parameterized builds in Pipeline projects, including using Groovy scripts for checkbox, radio button, and multi-select UI widgets, and handling reactive parameters with conditional logic.
The article explains that shared libraries, a familiar concept from languages like Python, are implemented in Jenkins as Groovy classes containing methods, helping to centralize pipeline code, avoid bloated Jenkinsfiles, and improve maintainability, while also promoting a live broadcast and group chat.
The article explains the concept of shared libraries, compares them to Python modules, describes how Jenkins Groovy shared libraries store classes and methods, and discusses their role in simplifying and standardizing pipeline code to avoid overly complex Jenkinsfiles.
The article explains the concept of shared libraries, compares them to Python modules, describes how Jenkins uses Groovy classes for reusable pipeline code, and highlights their role in simplifying and standardizing Jenkinsfile management while also promoting an upcoming live event.
This guide lists Jenkins REST API endpoints for project management tasks such as retrieving information, creating, disabling, enabling, deleting, and building jobs, and demonstrates how to wrap HTTP requests with the httpRequest step in a Jenkins pipeline using authentication tokens.
This guide introduces Jenkinsfile pipeline development utilities, covering a snippet generator, declarative syntax generator, essential global variables, and frequently used pipeline methods such as JSON handling, credential usage, source checkout, HTML reporting, interactive input, build user identification, and HTTP requests.
This tutorial explains how to configure Jenkins shared libraries, create Groovy utility classes, and integrate them into pipelines, covering library structure, code examples, required plugins, and usage within Jenkinsfiles to enhance DevOps workflows.
This article presents a comprehensive practical guide on using GitLab's built‑in CI/CD features for microservice projects, covering pipeline, stage, job concepts, .gitlab-ci.yml configuration, runner installation, Docker image building, registry push, and deployment strategies, supplemented with code snippets and diagrams.
To keep Git repository analysis up‑to‑date, this guide shows how to create a Jenkins pipeline that periodically or on‑demand runs GitStats, generates HTML reports, deploys them to Tomcat, and cleans up workspace, supporting multiple repositories with parameterized builds and email notifications.
This article explains how a CPU executes programs through the fetch‑decode‑execute cycle, describes instruction sets, registers, pipelines, superscalar and multithreaded designs, and details the cache hierarchy from registers to L3, providing a comprehensive overview of modern processor fundamentals.
This article outlines essential Jenkins Pipeline best practices, including using the official Pipeline plugin, treating pipelines as code, organizing work into stages and nodes, leveraging parallel execution, handling inputs with timeouts, and preferring stash over archive for artifact management.
This article explains how to construct a basic Tekton CI/CD pipeline on Kubernetes, covering core concepts, required resources, task definitions, pipeline templates, secret and ServiceAccount setup, execution monitoring, and includes full YAML and shell code examples for building, testing, and deploying a container image.
This guide demonstrates how to use several Jenkins Pipeline plugins—including readJSON, withCredentials, checkout, publishHTML, input, BuildUser, and httpRequest—to handle JSON data, manage credentials, retrieve source code, publish HTML reports, interactively collect input, obtain build user information, and perform HTTP requests within a CI/CD workflow.
This guide explains how to configure Artifactory in Jenkins, set up server credentials, and use both a Jenkins Shared Library and a Jenkinsfile to automatically publish build artifacts to Artifactory as part of a CI/CD pipeline.
This article describes how an e‑commerce platform built a big‑data pipeline—including TTLog, Lindorm, BCP, MetaQ, Blink and Xflush—to detect and verify search advertising placement errors in real time, covering background, implementation details, core challenges, and future optimization directions.
This article provides a comprehensive tutorial on using Jenkins Pipeline environment variables, covering how to list, read, set, override, store boolean values, and capture shell command output, complete with practical Groovy code examples for CI/CD workflows.
Jenkins pipelines, defined as Groovy code, enable version‑controlled, reusable CI/CD jobs for complex multi‑service environments, simplifying repetitive tasks such as URL updates, providing change tracking, and automating builds, tests, and releases across branches via Jenkinsfile.
This article explains the core principles of CPU operation, covering the fetch‑decode‑execute cycle, instruction sets, registers, pipeline and superscalar designs, multithreading and multicore behavior, as well as cache hierarchy from registers through L1‑L3, illustrating how these mechanisms affect program execution.
This article explains how to add interactive user input to Jenkins pipelines by installing the Pipeline: InputStep plugin, configuring a Jenkinsfile with various parameter types, and reviewing the resulting console output, enabling more flexible DevOps workflows.
This article outlines practical DevOps techniques for building Jenkins CI/CD pipelines triggered by GitLab webhooks, detailing both push‑triggered pipelines and merge‑request pipelines, including configuration steps, token handling, code quality checks, and notification mechanisms to streamline automated builds and reviews.
This article provides an in‑depth overview of MongoDB’s aggregation framework, explaining the concepts of pipelines and stages such as $match, $group, $project, $lookup, $unwind, and $out, and includes practical code examples, syntax details, and comparisons to SQL aggregation.
This document provides a detailed, chapter‑by‑chapter guide to Jenkins, covering its fundamentals, installation on various platforms, management, integration with tools, pipeline creation for frontend, backend, and mobile projects, as well as container deployment and monitoring solutions.
This guide introduces Tekton, a Kubernetes‑native CI/CD framework, and walks through installing it on an OKD cluster, creating and running a simple Task and TaskRun, handling image pull issues, and verifying pipeline execution, providing practical commands and YAML examples.
This guide explains how Knative Eventing's Sequence CRD enables multi‑step event pipelines, walks through its spec definition, and demonstrates four practical usage patterns—direct service calls, event‑driven processing, cascading sequences, and Broker/Trigger integration—complete with YAML examples and visual diagrams.
This article presents Xianyu's intelligent publishing solution that leverages real‑time mobile AI to automatically associate user‑uploaded items with existing catalog entries, balancing low user cost, high accuracy, and system performance through a multi‑layer architecture and flexible pipeline design.
This article explains the rise of Tekton as a Kubernetes‑native CI/CD framework, compares it with alternatives like Jenkins X, Spinnaker and Argo Rollout, and presents a practical case study showing how Tekton can automate complex stateful middleware deployments across multi‑cloud clusters.
This article explains how to use Jenkins' Lockable Resources Plugin to lock and release virtual machines across Linux, AIX, Windows, Solris, and HP‑UX, ensuring that concurrent jobs do not interfere with each other's environments during development and testing.
The article explains how Jenkins' multi‑branch pipelines can be extended for enterprise‑scale CI/CD by using dynamic pipeline creation, centralized shared libraries, governance practices, and the Remote File Plugin to centralize, secure, and simplify pipeline script management across many projects.
This tutorial walks through installing NFS, creating PersistentVolume and PersistentVolumeClaim, deploying Jenkins as a Kubernetes Deployment with a Service, configuring Jenkins credentials and plugins, and building a complete CI/CD pipeline that builds, pushes Docker images and promotes deployments across dev, qa, and prod environments.
This article presents the design, optimization, and deployment of a deep‑learning based ranking pipeline and model for NetEase News, covering offline and online pipelines, feature‑processing enhancements, custom TensorFlow operators, modular model architectures, and performance improvements demonstrated in production.
This tutorial walks through installing Jenkins, InfluxDB, and Grafana, configuring Jenkins plugins, creating the InfluxDB database and user, writing a pipeline script to publish build metrics, and setting up Grafana dashboards with variables to visualize Jenkins build data.
This article explains how Xianyu transformed its fast‑growing business by adopting a lean 2‑1‑1 development model and building an automated, unmanned client‑side continuous integration pipeline that cuts release cycles, reduces manual effort, and improves quality through measurable metrics.
This guide explains Jenkins project management, covering naming conventions, creating new projects, configuring build history, parameterized builds, triggers, Jenkinsfile setup, as well as building, viewing logs, and debugging pipelines with illustrative screenshots.
This document provides a comprehensive outline of Jenkins practice, covering fundamentals, installation on various platforms, management, integrations with tools like Maven, GitLab, and SaltStack, and detailed pipeline examples for front‑end, back‑end, and mobile projects.
This article explains the RESP protocol used by Redis, details its five data types, demonstrates pipeline handling with raw sockets, examines the parsing and command‑packing logic of the redis‑py client, analyzes the pipeline implementation and limitations of redis‑py‑cluster, and speculates on upcoming RESP3 features.
