This guide walks you through setting up Jenkins to pull code from GitLab, build a SpringBoot 3 Java project with Maven, back up and copy JAR files to a remote server, and perform rolling updates of Docker Swarm services, all with step‑by‑step instructions and code snippets.
The article explains how platform engineering—a cloud‑native discipline for building self‑service toolchains—enhances API development by improving developer experience, enabling better API integration, discovery, management, and CI/CD pipelines, ultimately providing a more customizable and efficient development environment.
This article provides a step‑by‑step guide for PHP developers on installing Jenkins, creating a freestyle job, configuring source control, setting environment variables, writing build scripts, defining post‑build actions, and running the job to achieve automated packaging and deployment of PHP applications.
This interview recounts Hervé Le Meur’s path from a B2B marketing consultant to a Jenkins infrastructure SRE, detailing his work with Jenkins X, Kubernetes, CI/CD pipelines, and the lessons he shares for newcomers to open‑source contributions.
This tutorial shows how to containerize a Go web application with Docker, use Beego for routing, set up development and production Dockerfiles, run automated tests, and integrate Semaphore for continuous integration and deployment, enabling consistent environments and streamlined workflows.
This guide walks through installing Jenkins in a Docker container, configuring the initial admin password, installing essential plugins such as NodeJS, Publish Over SSH and DingTalk, setting up Node.js mirrors, defining SSH deployment, creating a freestyle job that pulls a Git repository, builds the frontend with pnpm, and automates deployment and notifications via webhooks for both GitHub and GitLab.
This article describes how Agoda engineers tackled slow CI pipelines caused by exhaustive UI testing by implementing selective testing using code‑coverage data, JaCoCo, and a device farm, resulting in faster feedback, reduced flakiness, and more efficient integration for Android applications.
The article introduces AREX, Ctrip’s open‑source traffic recording and replay platform, detailing its background, design decisions, technical challenges such as cross‑thread collection and non‑idempotent interfaces, deployment strategies, best‑practice integration with CI/CD pipelines, and the measurable benefits achieved across thousands of applications.
The article shares a tester’s personal journey from functional testing to automation, explains why programming skills are essential, and provides a detailed, step‑by‑step learning roadmap covering Python, Selenium, Appium, API testing, CI/CD and framework development to help newcomers advance their careers.
This article explains how to manage Jenkins deployment permissions using RBAC and the Role‑Based Authorization Strategy plugin, covering RBAC fundamentals, plugin installation, creating users, jobs, groups, roles, and assigning permissions to ensure secure and organized pipeline access.
This article compiles thirty actionable tips that cover the entire software development lifecycle—from technical selection and tooling to CI/CD, monitoring, and knowledge sharing—helping engineering teams dramatically improve collaboration, productivity, and delivery quality.
This article introduces the key DevOps tools—including CI/CD platforms, configuration‑management solutions, containerization technologies, monitoring and logging stacks, and infrastructure‑as‑code utilities—explaining their roles, features, and how they help streamline software delivery in modern enterprises.
This article provides a comprehensive guide on using Jenkins Pipeline to automate the deployment of Java backend projects, covering pipeline concepts, parameterized builds, code checkout, Maven compilation, JAR packaging, remote uploading, backup, update, and service restart procedures.
The author recounts his early DevOps experiences with continuous integration using TFS, PowerShell, and Azure, reflects on the current undervaluation of DevOps, reviews the “Jenkins 2.x Practical Guide” and highlights sociological insights and practical challenges of adopting CI/CD pipelines.
This article presents a comprehensive view of cloud stability governance from both front‑end and back‑end perspectives, detailing system architecture, micro‑frontend integration, CI/CD deployment pipelines, SLB forwarding and health‑check configurations, monitoring dashboards, UI automation testing, and the resulting operational improvements.
This article explains how to use Jenkins Pipeline to automate the deployment of a Java backend project, covering pipeline basics, parameterized builds, GitLab branch checkout, Maven compilation, JAR packaging, remote file transfer, backup, update, and service restart with Docker Swarm.
This article details a comprehensive, front‑and‑back‑end approach to cloud stability, covering system architecture across private and public clouds, micro‑frontend integration, CI/CD pipelines, SLB routing, health‑check configurations, monitoring dashboards, data reconciliation, UI automation testing, and the resulting improvements in observability, gray‑release, rollback, and incident reduction.
This article explores the GitOps approach for cloud‑native environments, detailing its principles, benefits, and step‑by‑step implementation—including standardized content storage, declarative configuration, automated deployment/rollback, and change verification—to boost development efficiency and reliability.
This article explains Go's GOCACHE environment variable, detailing its role in caching compiled objects, how it speeds up builds and supports cross‑project reuse, and provides practical steps to view, clean, and configure the cache while avoiding stale‑cache pitfalls in development and CI/CD pipelines.
This article explains what GitHub Reusable Workflows are, outlines step‑by‑step how to create and invoke them across repositories, provides example YAML code, shares seven best‑practice recommendations, and compares them with Jenkins Shared Libraries to help teams improve CI/CD automation.
This article explains the essence of DevOps pipelines, outlines the characteristics of a high‑quality pipeline model—including clear layering, strong orchestrability, fan‑in/fan‑out support, and multi‑condition execution—illustrates real‑world analogies, and details how cloud‑native pipelines upgrade to a three‑layer stage/atom architecture with both graphical and YAML orchestration options.
This article explains the fundamentals of DevOps pipelines, outlines the characteristics of an excellent pipeline model such as clear layering, high orchestrability, fan‑in/fan‑out support, and flexible execution conditions, and describes how cloud‑native pipeline models are upgraded with stage and atom concepts, DAG orchestration, YAML configuration, and practical UI operations.
This guide walks through forking the php-windows-builder repository, configuring a GitHub Actions workflow, running the pipeline to compile PHP 8.3.2 and extensions on Windows, and downloading and verifying the resulting binaries and extension packages.
This guide outlines a step‑by‑step learning path for aspiring PHP developers, covering environment setup, core language fundamentals, front‑end basics, database mastery, popular frameworks, CI/CD practices, and additional topics such as security, version control, API design, performance optimization, and Linux deployment.
Development Containers use containerization, configuration-as-code, and Dev‑Prod parity to provide repeatable, shareable development environments that streamline CI/CD, reduce "works on my machine" issues, and boost team collaboration.
This article showcases a comprehensive collection of fourteen detailed diagrams illustrating various automation testing frameworks—including API, UI, mobile, JMeter, CI/CD pipelines, and DevOps practices—providing visual guidance for building robust test architectures across software development projects.
This article provides a comprehensive overview of DevOps history and principles, explains continuous integration concepts and benefits, compares popular CI tools such as Jenkins, GitLab CI/CD, Travis CI, Azure DevOps, and CircleCI, and demonstrates how to implement pipelines in Jenkins using both declarative and scripted syntax.
This article explains why software development productivity is hard to quantify, outlines key considerations for selecting meaningful metrics, and details essential DORA, cycle‑time, quality, customer‑feedback, employee‑satisfaction, and CI/CD indicators that help teams track progress without creating perverse incentives.
Learn how to set up a GitHub Actions workflow that builds a Docker image from a Dockerfile, tags it, logs into Docker Hub using repository secrets, and automatically pushes the image upon creating a new release tag.
Linear, the SaaS project‑management tool, suffered a catastrophic data loss when a TRUNCATE CASCADE command unintentionally wiped production tables, prompting a detailed post‑mortem that outlines the timeline, root cause, recovery steps, impact, and a set of concrete preventive measures.
This article explains how DevOps, through practices like CI/CD, automated testing, enhanced collaboration, infrastructure as code, continuous feedback, integrated security, and resource efficiency, can accelerate development, improve quality, boost security, and optimize resource utilization in modern software projects.
The article explains the importance of dynamic environment switching in testing frameworks for multi‑environment validation, resource isolation, debugging, and CI/CD, and provides Python unittest decorator examples along with best‑practice considerations such as scope, thread safety, resource management, and execution order.
McDonald's engineering team built a fast, reliable, and flexible continuous integration system by leveraging reusable GitHub Actions workflows, centralizing CI code, defining a golden‑path pipeline, balancing developer autonomy, and adding observability across multilingual microservices, improving productivity and maintainability.
This guide explains how to set up a Kubernetes pod to act as a Jenkins agent, covering prerequisites, deployment YAML, commands to launch and verify the pod and service, and the Jenkins UI configuration needed to connect the pod as a scalable CI/CD worker.
This article outlines the key technical and soft‑skill competencies—including programming, Linux, configuration management, infrastructure as code, CI/CD, networking, security, monitoring, and cloud services—that aspiring DevOps engineers need to master in order to effectively bridge development and operations.
Facing low development efficiency, poor CPU utilization, and fragile fault tolerance, the QQ Browser content ingestion team rebuilt a 93‑service microservice system into a single‑process, plugin‑driven architecture, achieving up to 13‑fold throughput gains, 10‑fold batch‑processing speedups, and dramatically reduced lead times and code complexity.
This guide walks through installing Jenkins and Nexus via Docker, configuring a Maven hosted repository in Nexus, setting up Jenkins credentials and plugins, and creating a Jenkins pipeline that builds a Maven project and publishes its artifacts to Nexus, enabling automated CI/CD for Java applications.
An extensive overview of essential DevOps tools for 2024, covering categories such as version control, CI/CD, container orchestration, configuration management, infrastructure as code, monitoring, collaboration, artifact repositories, testing, security, deployment automation, serverless platforms, and database management to guide effective tool selection.
This article provides a comprehensive overview of the Apache Software Foundation's infrastructure services and tools—including website hosting, email, self‑service platforms, version‑control repositories, issue‑tracking systems, CI/CD pipelines, code quality, publishing, virtual machines, and miscellaneous utilities—helping DevOps and SRE engineers understand and leverage Apache's operational ecosystem.
This article reviews the OpenKruiseGame project and its dashboard, showing how cloud‑native containerization, multi‑cloud support, and automated CI/CD pipelines transform game server deployment, scaling, and management for both PvP and PvE titles.
This article explains how to incorporate the SQLE SQL auditing tool into a DevOps workflow using GitLab, GitLab‑Runner, and Docker, detailing environment setup, CI/CD configuration, and automated scanning to ensure compliance and reduce production risks.
This guide walks through setting up a fully automated CI/CD pipeline that pulls code from Git, builds it with Maven, packages the resulting JAR into a Docker image, pushes the image to a registry, and finally deploys or updates the service on Kubernetes using Jenkins pipelines and supporting scripts.
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 article describes a systematic approach to reducing mobile app package size by detecting oversized resources, scanning unused assets, enforcing size checkpoints during development, and integrating automated validation into the CI/CD pipeline, illustrated with tools, workflows, and results.
This article explains two practical methods—using GitHub's native release.yml configuration and the third‑party Release Drafter tool—to automatically categorize GitHub Release Notes by title, complete with example configurations, code snippets, and a comparison of their features and limitations.
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 guide walks through selecting a blogging solution, setting up a Hexo site locally, deploying it to GitHub Pages using GitHub Actions, adding a theme, enabling comments, and mirroring the repository to Gitee for faster access, providing step‑by‑step commands and configuration files.
The paper describes Bilibili’s Caster platform, which implements standardized workflows, left‑shifted pre‑checks, tiered release checkpoints, and an emergency green‑channel to safely manage containerized application changes, providing real‑time observability, automated rollback, and capacity‑aware scaling that together cut change‑induced incidents and improve production stability.
This article explores the challenges of test environment deployment in modern DevOps, explains why Kubernetes offers a natural solution, details its design principles and core objects, and presents practical patterns for integrating Kubernetes‑based environments into CI/CD pipelines to achieve high cohesion, low coupling, and scalable testing 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.
The article explains the importance of CI/CD observability, outlines common pipeline problems, introduces Grafana's GraCIe plugin built on OpenTelemetry, and discusses how enhanced visibility can improve reliability, decision‑making, and future standardization across CI/CD platforms.
GitOps leverages Git's version‑control strengths to automate, codify, and make transparent infrastructure changes, combining IaC, merge requests, and CI/CD, while exploring its principles, toolchains like FluxCD, ArgoCD, Jenkins X, and practical implementations such as SRE Stack for end‑to‑end change management.
This article provides a detailed overview of the essential DevOps toolchain, covering planning tools, issue‑tracking systems, source‑code management, build automation, continuous integration and delivery, configuration management, cloud platforms, monitoring, communication, and knowledge‑sharing solutions.
This article explains how to generate and verify software artifact provenance with the Witness framework in non‑GitHub ecosystems, covering installation, key creation, configuration, running, signing, and policy verification to achieve higher SLSA levels.
The article explains what integration testing is, why it matters in micro‑service e‑commerce systems, demonstrates a Flask order‑creation example, and offers concrete planning, data, case, security, and CI/CD recommendations to ensure contracts between services work as expected.
This article outlines the essential steps for embracing DevOps culture, emphasizing tailored strategies, deep understanding of CI/CD, clear role assignments, extensive automation, key performance metrics, and the critical role of quality assurance to achieve faster, reliable software delivery.
This article details HuoLala's journey from a weekly release cycle to a cloud‑based record‑and‑replay mobile UI automation platform, covering background challenges, industry analysis, technical design—including deep‑learning based control detection, SIFT image matching, script generation, playback handling, and platform features—while demonstrating significant testing efficiency gains and future AI‑driven enhancements.
This guide explains how to deploy Jenkins as a Kubernetes pod, covering data persistence, Docker image download and tagging, RBAC setup, headless Service definition, and a StatefulSet with resource limits and volume claims for a robust CI/CD pipeline.
This article walks through building a comprehensive DevSecOps CI/CD pipeline in Jenkins that integrates source control, static analysis, vulnerability scanning, multi‑language builds, Docker image creation, Trivy security checks, Kubernetes deployment, and ZAP DAST testing to securely deliver applications across various runtimes.
This article explains how Jenkins and Kubernetes can be integrated to build a fully automated CI/CD pipeline, using Google’s real‑world implementation as a step‑by‑step example that covers installation, configuration, pipeline scripting, Docker image handling, and Kubernetes deployment.
This article details a B2C order processing case study, analyzing failure causes in automated test suites, introducing RocketMQ PullConsumer‑based MQ listening actions, and demonstrating how these changes together with CI/CD adjustments significantly raise test success rates despite increased execution time.
This article explains why front‑end teams should invest in technical infrastructure—covering fundamentals such as documentation, standards, scaffolding, component libraries, tooling, CI/CD, data monitoring, and micro‑frontend approaches—to improve efficiency, reduce blockers, and support future business growth.
This article explains what unit testing is, why it is essential for software quality, outlines its benefits such as early bug detection and design improvement, and provides practical guidance on writing effective Java unit tests using JUnit5, Mockito, and JaCoCo, along with CI integration and best‑practice principles.
This article outlines a comprehensive strategy for ensuring code quality within monorepo architectures by isolating unit tests via Git submodules, automating test execution in CI pipelines, and enforcing structured code reviews through a configurable Code Owner mechanism to mitigate integration risks.
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.
This article introduces Jianmu, an open‑source, highly extensible no‑code/low‑code CI/CD platform for DevOps, explains its purpose, provides online demo credentials, lists system requirements, and gives step‑by‑step deployment instructions using Docker‑Compose or Kubernetes along with a sample project setup.
This article introduces the OneBuild approach for cloud‑native image delivery, detailing how standardized Dockerfiles and shell scripts enable a single build to be reused across multiple deployments, cutting build time from 21 minutes to 7 minutes and improving efficiency by 66 %.
This guide explains how KubeVela, as a declarative application delivery control plane, leverages GitOps with FluxCD to provide end‑to‑end workflows, infrastructure and application deployment, multi‑cloud strategies, and automated CI/CD pipelines for both platform operators and developers.
This article explains why reliable rollback is essential, compares traditional and modern deployment methods, and details how containerized releases, OSS-based publishing, and mini‑program rollbacks can improve speed, consistency, and stability for development teams.
This article describes Huolala's journey from a legacy PHP codebase to a Java‑centric microservice architecture, the common misconceptions and difficulties of unit testing, and the design of an automated CI/CD pipeline that integrates Tekton, SonarQube, GitLab Runner, JUnit5, and Mockito to enforce coverage gates and improve code quality.
This article explores the fundamentals of code understanding, including static, dynamic, and non‑code analysis, presents a three‑layer architecture for scalable code comprehension, and demonstrates practical AI‑enhanced applications such as intelligent unit testing, dead‑code detection, and AI‑based static analysis within CI/CD pipelines.
This article provides a detailed overview of the most widely used DevOps tools across categories such as version control, CI/CD, container orchestration, configuration management, infrastructure as code, monitoring, collaboration, artifact repositories, testing, security, deployment automation, serverless, and database management, helping practitioners choose the right solutions for their pipelines.
The article explains how Kargo, an open‑source, GitOps‑based platform built on Argo CD experience, addresses the complexities of multi‑stage CI/CD pipelines in Kubernetes by providing declarative stage definitions, promotion workflows, and advanced delivery features such as canary releases and A/B testing.
This guide explains how to replace the traditional manual jar deployment with an automated Jenkins pipeline using Docker Compose, covering Jenkins installation, container setup, unlocking the admin password, plugin configuration, global tool settings, and build‑release procedures.
This guide shows how to create daily etcd snapshots on a Kubernetes cluster, upload them to MinIO, and orchestrate the whole process with a Python script, CronJob, Docker, Drone CI/CD, and ArgoCD for seamless backup automation.
This article details the Bank of China's DevOps transformation, describing the challenges of disparate codebases, the adoption of a feature‑branch strategy, a seven‑step quality‑built workflow, toolchain enhancements, and measurable improvements in defect detection, delivery speed, and overall software quality.
Baidu’s white‑box code understanding platform combines static, dynamic, non‑code and LLM‑based analyses in a three‑layer architecture that accelerates C/C++ processing ninefold, supports multiple languages, and powers applications such as intelligent unit testing, orphan‑function cleanup and AI‑driven risk detection, while future integration with models like GPT‑4 aims to enable multi‑turn code Q&A, automated refactoring and predictive testing.
This article introduces five open‑source DevSecOps tools—Trivy, Gerrit, OWASP Dependency‑Check, Arachni, and Falco—that help integrate automated security checks into CI/CD pipelines, improve vulnerability detection, and ensure compliance throughout the software delivery process.
This article describes how Razorpay formed a frontend core team, defined its responsibilities, tackled infrastructure and design inconsistencies, and built a monorepo‑based toolchain and design system to improve developer experience, scalability, and product quality across the organization.
This article provides a step‑by‑step guide to using CMake for cross‑platform builds, covering fundamental concepts, basic project setup, adding versioning and configuration headers, creating libraries, optional components, installation, testing, packaging with CPack, dashboard integration, and practical usage within JetBrains CLion for C/C++ development.
The US Air Force’s U‑2 reconnaissance aircraft has adopted a Jenkins‑driven CI/CD pipeline orchestrated by Kubernetes, enabling automated builds, repeatable deployments, rapid threat response, enhanced security, and resource savings, with a detailed step‑by‑step case study illustrating code management, pipeline configuration, container deployment, testing, and RBAC controls.
This article examines the governance of WeChat's NLP algorithm microservices, outlining the management, performance, and scheduling challenges they face and presenting solutions such as automated CI/CD pipelines, dynamic scaling, DAG‑based service composition, a custom tracing system, the PyInter interpreter, and an improved load‑balancing algorithm.
This article outlines key principles and best practices for designing a scalable Python automated testing architecture, covering test strategy definition, framework selection, modular and keyword‑driven design, test data management, error handling, reporting, CI integration, and provides a complete example implementation.
DevOps testing integrates continuous, automated testing throughout the software development lifecycle, shifting left from traditional isolated testing, emphasizing automation, appropriate tool selection, metric tracking, documentation, and dedicated test automation engineers to ensure high‑quality, rapid software delivery.
To keep ahead of hackers and fraud, a global cybersecurity firm replaced its fragmented cron‑based build, test, and release processes with a unified Jenkins CI/CD pipeline, integrating GitLab, Docker, and monitoring tools, thereby automating deployments, improving visibility, and streamlining DevSecOps across multiple projects.
The article explains that unit, integration, and functional testing should be fully automated and managed by CI/CD platforms to boost release confidence, avoid regressions, and prevent manual testing from slowing down deployment cycles.
This guide walks through installing Jenkins on a Kubernetes cluster using manual YAML manifests, configuring persistent storage, service accounts, ingress, and then demonstrates both static and dynamic Jenkins agents, including pipeline setup, plugin installation, and CI/CD workflow execution.
This article explains what a deployment pipeline is, outlines design principles for keeping pipelines simple and efficient, describes how pipeline design relates to branch strategies, and provides detailed naming conventions and label rules for different pipeline types, triggers, and quality‑gate metrics.
This article provides a comprehensive guide to Jenkins pipelines, explaining the differences between declarative and scripted syntax, detailing pipeline components such as agents, stages, steps, directives, post actions, and showing numerous practical code examples for building robust CI/CD workflows.
This article explains how containers work, outlines the challenges of detecting and fixing vulnerabilities throughout the software lifecycle, and presents practical strategies—including CI/CD pipeline, registry, runtime, and host scanning—plus key principles for building a robust container security program.
This comprehensive Kubernetes course covers core concepts, architecture, Kubeadm deployment, cluster management, containerized application deployment, CI/CD integration, advanced features like auto-scaling and Ingress, and provides extensive module listings, resources, and recommended readings for cloud‑native practitioners.
This article outlines ten advanced Playwright techniques—including the Page Object Pattern, async handling, popup and frame management, data‑driven testing, parallel execution, test data and environment management, logging, CI integration, and regular maintenance—to help developers build more reliable and scalable end‑to‑end test suites.
This article provides concise English explanations for common DevOps interview topics, covering the fundamental differences between DevOps and Agile, the reasons for adopting DevOps, its business and technical benefits, essential tools, CI practices, KPI metrics, and practical guidance for implementing DevOps in organizations.
This guide walks you through setting up an automated code deployment workflow using Docker, Kubernetes Deployments, and a CI/CD tool like Jenkins, covering environment preparation, image building, deployment configuration, pipeline scripting, monitoring, and rollback strategies.
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 article explains the importance of Docker for frontend development, covering its role as a consistent runtime environment, the benefits of standardized CI/CD pipelines, multi‑stage builds, caching strategies, and practical deployment patterns for static assets, Node.js services, and micro‑frontend architectures.
This article explains why measuring software development productivity is challenging, introduces the concept of DevOps metrics, details the four DORA indicators and their performance levels, and discusses additional metrics such as cycle time, quality, customer and employee satisfaction, CI/CD health, uptime, and service level indicators to help teams monitor progress and identify problems.
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.
By integrating Kubernetes with DevOps practices, teams can automate deployment pipelines, achieve dynamic resource allocation, centralize monitoring with tools like Prometheus and Grafana, and treat infrastructure as code, resulting in faster, higher-quality software delivery and improved collaboration between development and operations.
This article explains how to use GitLab CI and Kubernetes namespaces to automate building, testing, and deploying containerized services, ensuring environment isolation, resource control, traceability, and low operational overhead without introducing additional platforms.
