This article analyzes why Lettuce's mget on Redis Cluster performs poorly due to slot-based architecture, presents client-side refactoring using hashtags and pipeline‑based JedisCluster modifications, and shows benchmark results demonstrating up to double speed improvement over Lettuce.
This tutorial explains how to automate the full lifecycle of a Spring Cloud microservice—from developers pushing code to Git, Jenkins pulling and building it with Maven, packaging the JAR into a Docker image, pushing the image to a private registry, and finally deploying or updating the service on a Kubernetes cluster using YAML manifests.
This guide demonstrates how to use a Jenkins pipeline together with a single .tpl template and sed commands to automatically generate and deploy multiple Kubernetes configuration files, streamlining the deployment of numerous similar services while reducing maintenance overhead and error risk.
This article examines the fundamentals of DevOps pipeline models, outlines the characteristics of an excellent pipeline, compares JD's cloud‑native solution with competitors, and provides practical scenarios and step‑by‑step guidance for building, adjusting, and exporting pipeline workflows.
This article walks through the evolution of a Jenkins pipeline to not only build and push Docker images but also to deploy to Kubernetes with health checks for Deployments and StatefulSets, incorporating rolling update strategies and comprehensive status verification to ensure reliable CI/CD workflows.
This guide explains why and how to use the Git Parameter plugin in Jenkins to enable dynamic branch selection for both Freestyle and Pipeline jobs, covering configuration steps, code examples, and best practices for managing branch builds efficiently.
UnitEval is an open‑source toolbox that unifies prompts, provides a code‑quality pipeline, and offers extensible quality thresholds to automatically generate high‑quality code datasets for AI fine‑tuning, with detailed design principles, workflow steps, and usage instructions.
Jinkela Pipeline is an experimental front‑end DevOps glue tool integrated into the Dejavu platform that unifies and automates release workflows—handling environment variables, mono‑repo structures, parallel GitLab jobs, and plugin extensions—to reduce manual steps, inconsistencies, and anxiety for developers while enabling low‑code pipeline composition and future ChatOps integration.
This article walks through a production incident where a Redis Cluster pipeline caused Dubbo threads to block and eventually deadlock, detailing the root‑cause analysis, code inspection, and verification steps using jstack, jmap, and MAT to confirm the deadlock and propose fixes.
The article explains how performance can be dramatically improved by keeping frequently used data in CPU registers instead of memory, understanding basic assembly syntax and instruction types, using branch‑prediction hints, and exploiting the CPU pipeline to reduce stalls and wasted cycles.
This article introduces Alibaba's Alink platform and its online learning capabilities, discusses common challenges in machine‑learning pipelines, explains Alink’s algorithm‑to‑application connection, various computation modes, usage methods, and details the evolution from Model Flow 1.0 to the more versatile Model Flow 2.0, including pipeline integration, incremental training, and embedding prediction services.
This guide explains how to configure Jenkins with the WeChat Mini Program Builder plugin, create a pipeline that builds the mini‑program, generates a QR code, and displays the latest QR image on the Jenkins dashboard for quick testing, including full pipeline and code examples.
Learn how to connect Jenkins Pipeline with Kubernetes to automate building, testing, and deploying containerized applications, covering prerequisite setup, detailed pipeline stages—including code checkout, Docker image creation, testing, registry push, and Kubernetes deployment—complete with code snippets and configuration tips.
This article explains how Redis transactions and pipelines can guarantee data consistency during high‑concurrency order processing while dramatically improving throughput, and provides Java code examples, feature comparisons, usage guidelines, and practical case studies for backend developers.
This article explains the concept of a software delivery pipeline, traces its evolution from traditional release processes through basic CI/CD pipelines to the current quality‑efficiency pipeline, and outlines future plans to integrate large language models for intelligent orchestration, testing, and deployment.
This tutorial walks you through creating a Jenkins Pipeline job, writing the Groovy‑based script, defining agents, stages, and steps, configuring parameters, running the pipeline, and viewing detailed build output, providing a complete hands‑on guide for CI/CD automation.
This guide reviews the ten most popular CI/CD platforms—including GitLab, Azure DevOps, GitHub Actions, CircleCI, Jenkins, Travis CI, Bitbucket Pipelines, TeamCity, Semaphore, and Harness—detailing their core capabilities, unique strengths, and key considerations to help teams select the right tool for streamlined software delivery.
This article introduces the Jenkins Deploy Dashboard plugin, explains how to visualize deployment status across environments, add new releases to the dashboard, create custom deployment views, and integrate deployment buttons into pipelines using both scripted and declarative Jenkins pipelines.
This guide explains Jenkins pipelines, covering the two syntax styles—Declarative and Scripted—along with agents, stages, steps, directives, parameters, triggers, environment variables, credential handling, parallel execution, and post‑actions, providing complete code examples for each feature.
This guide explains what Jenkins pipelines are, compares declarative and scripted pipeline syntax, details pipeline components such as agents, stages, steps, directives, post actions, parameters, triggers, and parallel execution, and provides complete Jenkinsfile examples for each concept.
This tutorial explains how to use Jenkins shared libraries to consolidate repetitive pipeline code, set up Jenkins with Docker Compose, define reusable Groovy methods, create Docker build files, and configure pipeline jobs for maintainable, version‑controlled CI/CD workflows.
The article defines pipeline domain design concepts, compares major multimedia frameworks such as FFmpeg, GStreamer, MediaPipe and AVPipeline, and demonstrates a configurable, extensible node‑based architecture that enables fast plugin integration and adaptable audio‑video pipelines across diverse business scenarios and platforms.
This article introduces the Jenkins File Operations plugin, explains how to install it, generate the required DSL, and run a pipeline that creates, lists, and cleans up files, providing a complete code example and build log screenshots for reference.
This article provides a comprehensive guide to Jenkins pipelines, explaining the difference between declarative and scripted syntax, detailing agent configurations, workspace volumes, post actions, directives, environment variables, dynamic variables, credential handling, and practical Jenkinsfile examples for CI/CD automation.
This article presents a detailed guide on implementing DevOps principles in frontend development, covering background challenges, pipeline architecture, workflow design, tool integration, and step‑by‑step practices to improve delivery efficiency, code quality, and team collaboration.
This tutorial explains why and how to use Git parameters in Jenkins freestyle and pipeline jobs to enable dynamic branch selection, covering configuration steps, example Jenkinsfiles, and best practices for managing branch builds in DevOps environments.
This article explains how to use the parallel step and the Groovy collectEntries method in Jenkins Pipelines to run multiple jobs concurrently, reduce build time, and transform collections into maps for flexible stage generation, providing complete code examples and practical guidance.
This article explains how to build a Jenkins-based continuous integration pipeline, covering Jenkins fundamentals, pipeline architecture, Groovy DSL components, task conversion, API interactions, deployment strategies, and performance considerations for reliable CI/CD operations.
This article provides a comprehensive overview of Redis, covering why it is used as a cache, its single‑threaded efficiency, multithreading in version 6.0, common data structures and their use cases, pipeline advantages, persistence mechanisms, transactions, Bloom filter for massive URL checks, internal data organization, and incremental rehashing.
This article explains what a Jenkins Pipeline is, outlines its role in CI/CD and DevOps, and provides step‑by‑step instructions for creating pipeline jobs using both inline Pipeline Script and SCM‑based Jenkinsfile approaches, including sample code and GitLab trigger configuration.
This article explains how introducing a remote cache backed by CFS and Zstandard compression into cloud‑native CI/CD pipelines dramatically reduces build times by 3‑5 times, outlines the implementation steps, tool choices, cache key strategy, eviction policy, and showcases performance gains across Java, Node.js, Go, and GCC builds.
This article walks beginners through the fundamentals of DevOps by outlining a practical five‑step process for creating a CI/CD pipeline, covering tools for continuous integration, source control, build automation, web server deployment, test coverage, and optional extensions such as containers and middleware automation.
This article outlines a four‑step workflow to improve VR scene quality—covering hardware upgrades, optimized shooting setups, advanced image preprocessing, and custom color‑filter styling—demonstrating how systematic enhancements and blind testing can produce visually appealing, high‑quality VR experiences.
China Postal Savings Bank’s DevOps R&D Collaboration Platform and the Xingchen Platform’s Golden Bull Automated Testing System achieved top‑level evaluations in pipeline, CI/CD, and interface testing, showcasing how standardized tools and continuous delivery pipelines can dramatically improve quality, efficiency, and competitiveness in large enterprises.
The article details Chromium’s rendering pipeline, tracing how network bytecode becomes on‑screen pixels through 13 stages—from parsing and style calculation to layout, painting, compositing, tiling, rasterization, activation, aggregation, and final display—while explaining process models, component formulas, and synchronous versus asynchronous raster strategies.
This guide demonstrates how to use Jenkins' currentBuild.changeSets variable within a pipeline script to obtain the list of files changed between builds, as well as the commit ID, author name, and commit message, enabling conditional flow control based on these details.
This article explains how to customize Jenkins build names and descriptions by setting the currentBuild.displayName and currentBuild.description variables within a pipeline, providing a sample script that incorporates environment, server group, and artifact version details for clearer build identification.
This article delves into the internal design and execution of Java 8 lambda expressions, dissecting the Stream API pipeline—from source creation through intermediate operations like map and filter to terminal actions such as collect and sum—while illustrating each step with concrete code examples.
This article provides a comprehensive guide to Jenkins pipelines, covering the differences between declarative and scripted syntax, key directives, agents, stages, parallel execution, environment variables, credentials, and post‑processing steps, all illustrated with complete code examples.
This guide explains how to install and configure the Jenkins Pipeline Linter Connector extension in VSCode to perform local syntax validation of Jenkinsfiles by invoking the remote Jenkins API, and walks through the steps to validate a Jenkinsfile directly from the editor.
This article explains how AlertManager processes Prometheus alerts through a pipeline of stages—including gossip settlement, inhibition, silencing, waiting, deduplication, retry, and notification—detailing each stage's purpose and providing Go code examples of their implementations.
This article explains how to manage multiple microservice projects with GitLab groups and Jenkins, demonstrating the use of Jenkins pipeline's parallel syntax for both parallel tasks and parallel stages, and provides a master job script that triggers builds concurrently to speed up deployments.
This article explains the core concepts, architecture, and source‑code details of StarRocks’ Pipeline execution framework, covering BE initialization, query lifecycle management, operator splitting, PipelineBuilder processing, and the scheduling logic of PipelineDriver, with concrete code examples and diagrams to illustrate each step.
The annotation‑driven auto‑pipeline framework generates a linked‑list responsibility chain from @AutoPipeline‑annotated interfaces, automatically wiring handler implementations to execute sequentially and return the first non‑null result, thereby boosting development efficiency, reusability, and correctness for complex business pipelines such as configuration sources and message throttling.
This article explains the core concepts, architecture, and code logic of StarRocks' Pipeline execution framework, covering ExecPlan, PlanFragment, Fragment Instance, ExecNode, SourceOperator, SinkOperator, PipelineDriver scheduling, asynchronous handling of blocking operations, and the roles of FE and BE in MPP scheduling.
This article outlines eight enduring ideas—from designing for Moore's Law and using abstraction to speeding up common cases, leveraging parallelism, pipelining, prediction, memory hierarchy, and redundancy—that have shaped computer architecture over the past six decades.
This article demonstrates how to install and configure the Jenkins Git Parameter plugin to automatically obtain branch information from a GitLab repository within a pipeline, covering setup steps, common errors, and tips for handling projects without a checkout stage.
This article explains how to implement DevSecOps across an enterprise using Jenkins Template Engine (JTE), covering preparation of library resources, pipeline template configuration, plugin installation, and a complete pipeline test with sample code and console output.
This article explains how Meituan built a unified, highly available pipeline engine that supports nearly 100,000 daily executions across dozens of services with 99.99% success, detailing the challenges faced, the architectural decisions made, and the future roadmap for further scalability and cloud‑native improvements.
This article details Meituan's three‑year journey building a self‑developed pipeline engine that now handles nearly 100,000 daily executions with over 99.99% reliability, covering background, challenges, architectural decisions, core scheduling and resource‑pool designs, component layering, and future cloud‑native plans.
This guide explains how to install the Tektoncd Operator on a Kubernetes cluster, configure its CRDs, choose installation methods, customize component images, apply predefined profiles, and run a simple hello‑goodbye pipeline using Tekton tasks and PipelineRun objects.
This article details Meituan's three‑year journey building a self‑developed, distributed pipeline engine that now handles nearly 100,000 daily executions across dozens of services with over 99.99% reliability, covering the challenges faced, architectural decisions, scheduling and resource‑pool designs, and future cloud‑native plans.
This article explains the fundamentals of scalable CI/CD pipelines, covering their definition, four core stages, key attributes for a high‑quality pipeline, and multiple practical examples across microservices, containerized, serverless, and cloud‑based environments.
This article introduces Tencent Music's cloud‑native, one‑stop machine learning platform, detailing its engineering workflow, distributed acceleration, inference closed‑loop, edge computing capabilities, and future plans, while highlighting challenges of traditional ML pipelines and the platform's solutions for resource orchestration, storage, scheduling, and GPU utilization.
This guide explains how to manually create Jenkins JNLP agents on a Kubernetes cluster, covering both static Deployment‑based agents and dynamic agents using the Kubernetes plugin, with detailed YAML definitions, pipeline scripts, and supporting helper functions for a complete CI/CD workflow.
This article provides a detailed walkthrough of Scrapy, covering its event‑driven architecture, component interactions, XPath parsing fundamentals, installation steps, project creation, sample spider code, item pipelines, middleware customization, and essential configuration settings for effective web crawling in Python.
Baijiahao’s text‑to‑video pipeline now relies on After Effects for rendering and composition, using standardized templates, JavaScript‑based AE scripts, and aerender command‑line features such as reuse, multi‑frame and network rendering to achieve rich visual effects with lower R&D cost, though browser preview and cross‑platform deployment remain limited.
This article provides a comprehensive overview of DevSecOps, explaining its definition, pipeline stages, detailed framework, and the top five best practices for 2022 to help organizations integrate security throughout the software development lifecycle.
This article thoroughly explains libunifex’s sender/receiver model for C++ asynchronous programming, covering its design goals, module structure, pipeline composition, key functions like schedule, then, sync_wait, and the connect/start mechanisms, while demonstrating practical examples and integration with C++20 coroutines and cancellation support.
The article explains why modern enterprises must build three fundamental pipelines—code, data, and experiment—to achieve successful digital transformation, outlines their purposes, discusses construction strategies, and highlights challenges specific to each pipeline.
Over the past two years Alibaba’s DX native dynamic framework has been re‑engineered by moving virtual‑node parsing, layout and drawing to background threads, adding an asynchronous drawing system, a unified rich‑text component, and off‑screen resource management, boosting low‑end device frame rates from ~30 FPS to over 55 FPS and cutting media‑CPU usage by 65 % while paving the way for richer interactive UI features.
This tutorial explains how to use Jenkins, the Git Parameter plugin, and parameterized builds to fetch and display Git branch information within a pipeline, including installation steps, configuration details, and common troubleshooting tips.
This article introduces the Deploy Dashboard plugin for Jenkins, explains how to visualize deployment status across environments, shows step‑by‑step instructions for adding versions, creating the dashboard view, adding deployment buttons, and provides pipeline code examples for seamless CI/CD integration.
This tutorial explains how to create and configure a Jenkins shared library, organize its directory structure, set it up in Jenkins global settings, and reference it from a Jenkinsfile to simplify pipeline management across multiple projects.
This article provides a comprehensive, step‑by‑step explanation of Netty’s pipeline architecture, detailing how ChannelHandlerContext wraps handlers, how inbound and outbound events are classified and propagated, and how handlers are added, removed, and initialized within the pipeline.
The article presents a modular, extensible content‑delivery pipeline for e‑commerce—comprising datasource, transfer, filter, sorter, completer, validator, factory and iterator nodes—implemented in Java, with JSON‑driven filter schemas, to simplify complex, low‑latency content handling, improve flexibility, and ease operations across evolving business requirements.
This article walks through converting a Jenkinsfile‑based pipeline to a Tekton Pipeline, adding Helm‑based deployment tasks, integrating SonarQube scanning, handling multi‑branch releases across different namespaces, and demonstrates the full PipelineRun execution with code snippets and images.
This article provides a detailed guide to structuring GitLab CI/CD pipelines for Java projects, covering job templates for building, testing, code analysis, artifact handling, and Kubernetes deployment, along with variable definitions, workflow rules, and stage configurations to enable flexible and automated DevOps workflows.
This guide explains the fundamentals of CI/CD, the benefits of automation, and provides a step‑by‑step tutorial on configuring GitLab CI/CD pipelines, including .gitlab-ci.yml syntax, job and stage definitions, runner installation, manual approvals, and scheduled executions using cron syntax.
This article provides a detailed technical analysis of GPUImage2’s pipeline architecture, explaining the core concepts, operator overloads, internal relationships such as TargetContainer and SourceContainer, framebuffer management, OpenGL ES integration, and thread‑dispatch mechanisms, all illustrated with Swift code examples and diagrams.
This article explains Tekton’s core CRDs—Task, TaskRun, Pipeline, PipelineRun, PipelineResource, and Condition—how they are implemented on Kubernetes, how pipelines are built and executed, and how to manage secrets and service accounts for secure CI/CD workflows.
The article details how DaJia's recommendation system progressed through three architectural versions—V1.0's simple strategy‑factory design, V2.0's vertical business split and configurable pipeline, and V3.0's dynamic configuration service and modular pipeline—addressing scalability, fault isolation, and personalization challenges while outlining future directions for explainable AI recommendations.
The article examines a puzzling StackOverflow case where sorting a random array before summation yields a six‑fold speedup, explains the phenomenon through CPU five‑stage pipeline fundamentals, structural, data, and control hazards, and shows how branch prediction and operand forwarding mitigate the performance loss.
This comprehensive guide walks you through Redis basics, its data structures, commands, installation steps, high‑concurrency principles, persistence mechanisms, replication, caching strategies, Lua scripting, pipelines, distributed locks, and cluster concepts, providing practical examples and best‑practice recommendations for developers and operators.
This comprehensive guide explains what GitLab CI is, how to configure shared or custom runners with Docker, register them, create and write a .gitlab-ci.yml file using YAML syntax, and demonstrates basic and advanced pipeline demos with full code examples and images.
This article details the evolution of an e‑commerce recommendation system through three architectural versions, highlighting the initial simple design, the challenges that prompted vertical and horizontal splits, the introduction of a configurable pipeline and AB testing, and the final micro‑service‑based, dynamically configurable V3.0 architecture.
This guide explains why and how to use the Git Parameter plugin in Jenkins to enable dynamic branch selection for both Freestyle and Pipeline jobs, covering configuration steps, parameter definitions, and example Jenkinsfile scripts for various pipeline setups.
This article describes the progressive redesign of an e‑commerce recommendation platform—from a simple strategy‑factory V1.0 through a vertically split V2.0 to a fully configurable, pipeline‑driven V3.0—highlighting architectural challenges, Redis clustering, dynamic configuration, recall and prediction services, and future directions for fine‑grained, explainable recommendations.
This article details the three‑stage evolution of an e‑commerce recommendation framework—V1.0’s simple strategy‑factory design, V2.0’s vertical business split, and V3.0’s configurable pipeline with dynamic server‑client configuration, addressing scalability, isolation, and AB‑testing challenges.
This article details the evolution of the "到家" recommendation system across three major versions, describing the initial strategy‑factory prototype, the problems it faced, the vertical and horizontal splits introduced in V2.0, the dynamic pipeline configuration and service separation in V3.0, and the future outlook for finer‑grained personalization.
This article examines the step‑by‑step evolution of the recommendation framework used by a major e‑commerce service, detailing the shortcomings of the initial V1.0 design, the vertical and modular refinements introduced in V2.0, and the dynamic configuration, pipeline, and service‑oriented enhancements implemented in V3.0 to improve scalability, stability, and fine‑grained experimentation.
This guide introduces GitLab CI/CD by explaining pipelines, jobs, stages, runner registration, and SSH‑based deployment, providing a complete example .gitlab-ci.yml and Docker‑based runner setup for beginners who want to automate build, test, and release processes.
This article demonstrates how to build a reproducible fraud‑detection workflow using scikit‑learn's Pipeline class, comparing a manual script with a pipeline‑based approach on the IEEE‑CIS Kaggle dataset and showing the benefits of modular, repeatable ML code.
This article details a structured GitLab CI/CD setup using job templates for build, test, code analysis, artifact handling, and Kubernetes deployment, combined with a default-pipeline.yml that defines includes, global variables, workflow rules, stages, and environment‑specific deployment configurations for Java applications.
This guide walks through installing Jenkins and Nexus Repository Manager with Docker, configuring a Maven hosted repository, adding Nexus credentials and Maven tools in Jenkins, and creating a Jenkins pipeline that builds a Java project and publishes its artifacts to Nexus, illustrating a complete CI/CD workflow.
This article explains why and how to convert Jenkins Freestyle projects to Pipeline jobs, covering trigger mechanisms, global and repository configurations, shell build steps, and a complete scripted pipeline example that automates building, testing, reporting, and email notifications.
To enhance decision‑making for users and quality monitoring for merchants, Meituan’s to‑restaurant platform implements fine‑grained aspect‑based sentiment analysis that extracts dish, attribute, opinion and polarity tuples from reviews, employing both a BERT‑CRF pipeline and a joint Dual‑MRC model which raise F1 scores from 0.61 to 0.68, and are deployed in dashboards and review‑management tools, with future work targeting efficiency and broader four‑tuple extraction.
This article introduces the Jenkins Deploy Dashboard plugin, explains its purpose for visualizing deployment status across environments, and provides step‑by‑step instructions—including adding deployments to the dashboard, creating the dashboard view, and adding deployment buttons—using both scripted and declarative pipelines.
This article introduces Jenkins Pipeline fundamentals, explains stages, nodes, and steps, compares Declarative and Scripted syntaxes, and provides detailed code examples for Windows, Docker, and Git operations to illustrate building, testing, and deploying applications.
The article examines Jedis 3.5.0’s three Redis access modes—single‑node via Jedis, sharding via ShardedJedis, and cluster via JedisCluster—detailing their class hierarchies, connection handling, consistent‑hashing and slot logic, and how pipelines boost throughput while respecting mode‑specific constraints.
Learn how to install Jenkins inside Docker using the jenkinsci/blueocean image, configure ports and volumes, unlock the instance, set up credentials for Git and SSH, create a multi‑branch pipeline with Blue Ocean, and write a Jenkinsfile that automates build, test, and deployment steps.
This case study describes how a rendering middle‑platform team tackled complex micro‑service chains, inconsistent data rules, and massive 3D data to create a full‑link location and visualization platform that enables self‑service debugging, reduces developer effort by over 30 %, and serves more than 170 monthly users.
This guide explains how to set up a Gerrit instance, configure SSH keys and permissions, install the Gerrit Trigger plugin in Jenkins, and create a Jenkins pipeline that automatically runs when a review is merged, providing a complete end‑to‑end CI/CD workflow.
This tutorial walks you through the fundamentals of Scrapy, covering its architecture, project setup, spider creation, item and pipeline definitions, pagination techniques, and multiple ways to store scraped data such as JSON files and MongoDB, all with clear code examples.
This article demonstrates how to set up a GitLab CI pipeline trigger token, use curl or Postman to invoke the pipeline via API, embed the trigger in .gitlab-ci.yml, and pass custom variables to the job, with example scripts and best‑practice tips.
This tutorial explains HTTP fundamentals, shows how to install and configure the Jenkins Generic Webhook Trigger plugin, and demonstrates parsing GET, POST, and header parameters using curl, Postman, and Jenkinsfile Groovy scripts for automated CI/CD pipelines.
The article reviews how deep learning models have grown deeper and wider, discusses the memory and bandwidth limits of single GPUs, and explains pipeline and sharding techniques—including GPU clusters and TPU pods—to efficiently train large‑scale models in industrial settings.
This tutorial explains how to use Jenkins to integrate command‑line tools and webhooks for automating GitLab branch creation, covering API discovery, Postman testing, pipeline scripting, credential handling, shared library implementation, and final system configuration.
This guide explains what Tekton is, outlines its core CRDs, shows how to deploy it on a Kubernetes cluster, and provides a step‑by‑step example that builds, containers, and deploys a Spring Boot application using Maven, Docker, and Tekton pipelines.
This article explains the fundamentals of CI/CD and pipelines, identifies eight common anti‑patterns such as lack of code‑as‑pipeline, slow execution, unstable results, misuse of production data, excessive complexity, tight coupling, zombie pipelines, and manual intervention, and provides practical causes and remediation strategies for each.
