Deployment pipeline
A deployment pipeline is a repeatable sequence of stages that builds, tests or validates, packages, and delivers software changes toward release or deployment.
Platform Engineering on Kubernetes
An automated sequence of activities that moves software changes toward release and deployment.
- How it is used
- Moves service changes toward releasable artifacts and connects them to validation and promotion across environments.
- How deep it goes
- Details triggers, build checks, artifact publication, infrastructure requirements, and the handoff to environment pipelines without prescribing one pipeline boundary.
- Examples
- Uses Conference application services, main-branch and pull-request runs, published container images, and environment-repository change requests.
- What you can do after
- Build it from scratch by separating artifact production from environment promotion and choosing checks, triggers, and publication points.
Read how Platform Engineering on Kubernetes explains deployment pipeline →
Bootstrapping Microservices, Second Edition: With Docker, Kubernetes, GitHub Actions, and Terraform
A CI/CD pipeline is an automated workflow that validates and delivers software changes through continuous integration and continuous delivery or deployment stages.
- How it is used
- Automates validation and deployment of microservice changes as repository updates arrive.
- How deep it goes
- Works from CI checks through locally tested deployment scripts, independent service workflows, and branch-based environment promotion.
- Examples
- Uses a Node.js video-streaming service and a gateway workflow scoped to one directory in a microservices monorepo.
- What you can do after
- Apply it via GitHub Actions to test changes and deploy microservices to Kubernetes.
Effective Platform Engineering
An automated deployment pipeline is a tool-driven sequence that builds, validates, and deploys software with minimal manual intervention.
- How it is used
- Moves platform changes through repeatable validation and release paths while reducing manual deployment work.
- How deep it goes
- Specifies environment progression, code identity, test stages, and release observation, with exercises for infrastructure pipelines.
- Examples
- Uses cross-account DNS delegation, VPC provisioning, and separate platform-service and extension pipelines.
- What you can do after
- Build it from scratch by piloting a validated release path, then measure deployment frequency, lead time, and failures.
Read how Effective Platform Engineering explains deployment pipeline →
Learn Docker in a Month of Lunches, Second Edition
A CI/CD pipeline is an automated sequence that builds, tests, packages, and delivers software through continuous integration and continuous delivery or deployment.
- How it is used
- Turns code changes into tested container images and, when configured, deploys the application.
- How deep it goes
- Works through Docker-based build steps, test failures, job configuration, and portability; leaves private-package authentication as additional configuration.
- Examples
- Uses a Jenkinsfile calling a Compose build script and a GitHub Actions workflow that runs a PowerShell build script.
- What you can do after
- Build it from scratch using Docker build scripts and a Jenkins or GitHub Actions job, then diagnose failures in build output.
Read how Learn Docker in a Month of Lunches, Second Edition explains deployment pipeline →
Microservices Patterns, Second Edition
An automated sequence that takes a software change through building, testing, and deployment.
- How it is used
- Uses fast automated pipelines to support rapid feedback and delivery of small changes.
- How deep it goes
- Explains triggers, build and test execution, deployment, isolation, and incremental-build caching without providing a pipeline configuration.
- Examples
- Illustrates separate Order and Delivery service pipelines and Gradle incremental builds with a cache for ephemeral environments.
- What you can do after
- Evaluate and understand pipeline boundaries and bottlenecks when choosing between a monolith and independently deployable services.
Read how Microservices Patterns, Second Edition explains deployment pipeline →
Spring Microservices in Action
An automated sequence of processes that builds, tests, and deploys software.
- How it is used
- Enables repeatable, low-friction delivery of independently deployable microservices.
- How deep it goes
- Walks through pipeline stages and a concrete configuration, while acknowledging that the implementation and deployment topology are simplified.
- Examples
- Uses a GitHub-triggered Travis CI build with Maven, Docker, and Amazon cloud deployment.
- What you can do after
- Apply it via GitHub, Travis CI, Maven, and Docker to build and deploy a microservice pipeline example.
Read how Spring Microservices in Action explains deployment pipeline →
Automating API Delivery
Continuous integration and continuous delivery is a software delivery practice that automates frequent integration, testing, packaging, and deployment.
- How it is used
- Coordinates API governance, artifact production, and deployment in a repeatable Git-based delivery workflow.
- How deep it goes
- Works through PR checks and a GitHub Actions build, including packaging and API-definition transformations; leaves design approval to reviewers.
- Examples
- Uses a PR build with Spectral and Tufin/oasdiff, plus a GitHub Actions workflow that builds an image and bundles OpenAPI.
- What you can do after
- Build it from scratch with GitHub Actions to check API changes and produce service and API-definition artifacts.
Read how Automating API Delivery explains deployment pipeline →
Terraform in Depth: Infrastructure as Code with Terraform and OpenTofu
A CI/CD pipeline is an automated workflow that builds, tests, and delivers software through continuous integration and continuous delivery or deployment.
- How it is used
- Coordinates pull-request quality checks, change review, and deployment of Terraform infrastructure from the main branch.
- How deep it goes
- Works through job triggers, steps, test matrices, and a GitOps deployment sequence; leaves CD platform implementation to platform choice.
- Examples
- Uses a GitHub Actions TFLint workflow and test matrices spanning test cases, Terraform or OpenTofu engines, and versions.
- What you can do after
- Build it from scratch using GitHub Actions quality checks and a reviewed GitOps path to automated infrastructure deployment.
Infrastructure as Code, Patterns and Practices: With examples in Python and Terraform
A delivery pipeline is an automated sequence of activities that validates, packages, and delivers software or infrastructure changes.
- How it is used
- Organizes infrastructure changes into automated validation, review, deployment, and release stages.
- How deep it goes
- Explains pipeline stages, CI/CD variants, module releases, security controls, and idempotent migrations, but defers extensive migration practice.
- Examples
- Uses CI workflows, GitHub Actions with Google Cloud Run, module version releases, and blue-green database migration.
- What you can do after
- Apply via GitHub Actions a repeatable pipeline that tests infrastructure, gates releases, deploys environments, and migrates state safely.
Developer Experience on Kubernetes
CI/CD is shorthand for the combination of continuous integration with continuous delivery or continuous deployment.
- How it is used
- Connects frequent mainline integration to the outer-loop deployment pipeline from commit through production.
- How deep it goes
- Details commit-stage checks and names acceptance and production stages without elaborating their activities.
- Examples
- Uses daily mainline pushes, hidden incomplete features, commit-stage tests, static analysis, build artifacts, and failed-build fixes.
- What you can do after
- Apply it via frequent mainline pushes and a fast commit stage to gain early quality feedback.
Read how Developer Experience on Kubernetes explains deployment pipeline →
Vibe Engineering
The practice of continuously integrating code changes and continuously delivering or deploying validated software through automated pipelines.
- How it is used
- Enforces executable specifications and automated checks as AI-generated changes move toward release.
- How deep it goes
- Sets out checks by change, merge, recurring schedule, and major release, without detailing deployment automation.
- Examples
- Uses a 30-day refund policy with executable acceptance examples and boundary-focused property tests.
- What you can do after
- Operate a verification schedule with automated checks, human review, and additional tests selected by release risk.
Web Components in Action
A build step is an automated processing stage that transforms or prepares source code and assets for development or production.
- How it is used
- Transforms or prepares frontend code and assets between editing and browser use, including transpiling, bundling, and processing HTML or CSS.
- How deep it goes
- Explains npm scripts and Rollup component bundling, including output paths and chained builds, while leaving tool choice open.
- Examples
- Uses Sass and LESS compilation, HTML assembly, TypeScript transpilation, and Rollup bundles for component files.
- What you can do after
- Operate/configure npm scripts to run Rollup builds for individual components or chain several component builds.
Read how Web Components in Action explains deployment pipeline →
Shipping Go: Develop, deliver, discuss, design, and go again
A deployment pipeline is an automated sequence of steps that builds, verifies, and delivers software to a deployment environment.
- How it is used
- Automates the path from committed code through verification and build toward a product customers can use.
- How deep it goes
- Works through a trigger, job, steps, and artifact upload, but stops short of configuring a deployment to a running server.
- Examples
- Uses a GitHub Actions YAML workflow that builds a Go binary on pushes to main and uploads it as an artifact.
- What you can do after
- Build it from scratch with GitHub Actions as a small, automated build-and-artifact pipeline that can later gain more checks and deployments.
Read how Shipping Go: Develop, deliver, discuss, design, and go again explains deployment pipeline →
Google Anthos in Action
A CI/CD pipeline is an automated workflow that moves software changes through integration, validation, and delivery stages from source to production.
- How it is used
- Automates validation and delivery from source changes toward production.
- How deep it goes
- Defines CI and CD, then details Cloud Deploy manifests, targets, releases, rollouts, and approvals.
- Examples
- Uses a Hello World application and a test-to-staging-to-production deployment sequence.
- What you can do after
- Configure and operate Cloud Deploy releases across ordered target environments.
Read how Google Anthos in Action explains deployment pipeline →
Kubernetes for Developers
A deployment pipeline is an automated sequence of validation and delivery steps that promotes software or configuration changes to a deployment environment.
- How it is used
- Automates Kubernetes configuration rollouts from repository pushes so deployed changes follow committed configuration.
- How deep it goes
- Defines the repository trigger and sketches a Cloud Build setup, while deferring a complete end-to-end CI/CD flow.
- Examples
- Uses namespace-checking rollout scripts and a Cloud Build configuration that runs kubectl apply against a GKE cluster.
- What you can do after
- Apply it via Cloud Build by granting cluster access, creating a repository-push trigger, and configuring a kubectl deployment step.
Read how Kubernetes for Developers explains deployment pipeline →
100 SQL Server Mistakes and How to Avoid Them
A CI/CD pipeline is an automated workflow that integrates, tests, and delivers software changes through continuous integration and continuous delivery or deployment.
- How it is used
- Replaces manual database releases with a repeatable workflow for packaging, validating, and deploying incremental changes.
- How deep it goes
- Explains deployment rationale and DAC packaging, but defers granular configuration because tooling and enterprise requirements vary.
- Examples
- Uses MagicChoc’s manual deployment, DAC packages, Visual Studio publishing, SSMS registration, and SSDT Schema Compare.
- What you can do after
- Operate/configure a safer release process using DAC packaging, schema comparison, source control, and unit tests.
Read how 100 SQL Server Mistakes and How to Avoid Them explains deployment pipeline →
Grokking Software Architecture
An automated sequence of stages that builds, tests, and moves software changes toward deployment.
- How it is used
- Treats deployment as an architectural concern and uses automated gates to make releases repeatable.
- How deep it goes
- Explains verification, artifact building, promotion, and release sequencing, with a configuration example that emphasizes stage-gate logic over syntax.
- Examples
- Uses an order-service workflow and a blueprint exercise to illustrate verification, environment promotion, and release design.
- What you can do after
- Evaluate a deployment design for automated checks, progressive promotion, and infrastructure-specific release coordination.
Read how Grokking Software Architecture explains deployment pipeline →
Secure APIs
Continuous integration and delivery is an automated practice for frequently integrating code changes and validating or releasing them through a delivery pipeline.
- How it is used
- Protects API delivery by testing implementations thoroughly and preventing insecure releases.
- How deep it goes
- Describes testing and operational responsibilities without specifying pipeline configuration or implementation steps.
- Examples
- Uses fuzz testers, API security testing tools, integration tests, simulated user flows, and production monitoring.
- What you can do after
- Evaluate API delivery readiness and detect or block malicious behavior after deployment.
Build AI-Enhanced Web Apps
An automated software delivery workflow that integrates code changes and continuously builds, tests, and deploys them.
- How it is used
- Uses CI/CD to automate deployment as part of a production reliability checklist.
- How deep it goes
- Walks through Vercel project setup and CLI deployment, but does not detail pipeline test configuration.
- Examples
- Deploys a chat application using Vercel project settings, environment variables, and the CLI.
- What you can do after
- Apply it via Vercel to configure and deploy a chat application and inspect deployment errors.
Read how Build AI-Enhanced Web Apps explains deployment pipeline →
Architecture Modernization: Socio-technical alignment of software, strategy, and structure
A deployment pipeline is an automated sequence of stages that builds, tests, validates, and deploys software.
- How it is used
- Enables teams to reach production quickly while applying quality and compliance requirements.
- How deep it goes
- Defines a robust, secure production path with quality and compliance built in, but gives no implementation steps.
- Examples
- Cites new applications reaching production in hours or minutes and a government service deploying multiple times daily.
- What you can do after
- Evaluate how a paved production path can speed delivery while retaining quality and compliance requirements.
Think Like a Software Engineering Manager
Continuous delivery is a software delivery practice in which changes are kept in a releasable state and delivered frequently through an automated, repeatable process.
- How it is used
- Keeps valuable changes moving to customers through frequent delivery and iterative feedback.
- How deep it goes
- Describes the delivery cycle and operational responsibilities but does not detail pipeline implementation.
- Examples
- Uses a first production deployment with a teammate shadowing, plus iterative delivery and customer feedback.
- What you can do after
- Understand how iterative delivery and production support contribute to a continuing flow of customer value.
Read how Think Like a Software Engineering Manager explains deployment pipeline →
Designing AI Systems
A deployment pipeline is an automated sequence of steps that builds, packages, and releases software for execution in a target environment.
- How it is used
- Turns developer workflow code into packaged, routed, scalable services by coordinating deployment and operations outside request handling.
- How deep it goes
- Traces decorator metadata into container setup and workflow selection, but does not specify a complete build or rollout implementation.
- Examples
- Uses a patient-intake workflow configuration and separate images for two decorated workflows in one Python module.
- What you can do after
- Operate/configure deployments by setting workflow metadata that drives container resources, scaling, and runtime selection.
Read how Designing AI Systems explains deployment pipeline →
Road to Kubernetes
CI/CD is the practice of continuously integrating code changes and continuously delivering or deploying software through automated pipelines.
- How it is used
- Automates testing, configuration tasks, and delivery or deployment so code changes can move toward production repeatably.
- How deep it goes
- Defines CI, continuous delivery, and continuous deployment, but leaves automated-test authoring beyond scope.
- Examples
- Uses GitHub Actions workflows for tests and configuration automation, and compares automated container builds through GitHub Actions or Docker Hub.
- What you can do after
- Configure GitHub Actions pipelines to run tests and configuration automation, deploy code, and centralize runtime secrets.
Think Like a CTO
An automated sequence of software integration, compilation, testing, packaging, and deployment steps.
- How it is used
- Uses automated code building, testing, and deployment to support reliable releases as teams and codebases become more complex.
- How deep it goes
- Explains the merge-triggered build, test, and deployment flow, then gives security safeguards without implementation-level detail.
- Examples
- Uses a .NET build failure caused by machine updates and the SolarWinds attack to illustrate reliability and security risks.
- What you can do after
- Operate/configure pipelines by automating builds and deployments, separating build environments, locking dependency versions, and monitoring unexpected changes.
The Art of Unit Testing 3e
An automated workflow containing release-blocking tests and deployment steps that provides fast feedback and can authorize software release when successful.
- How it is used
- Separates release-blocking checks from nonblocking tests to provide fast feedback and a go/no-go release decision.
- How deep it goes
- Defines the release-check role and contrasts discovery testing, without detailing tools or implementation steps.
- Examples
- Contrasts fast, release-blocking tests with parallel, long-running good-to-know tests.
- What you can do after
- Operate a go/no-go release check that can automatically release code when blocking tests pass.
Read how The Art of Unit Testing 3e explains deployment pipeline →
Building Distributed Applications that Work
A software delivery pipeline is an automated sequence of steps for building, testing, or deploying software.
- How it is used
- Automates building, testing, and deploying Aspire applications instead of running deployment scripts manually.
- How deep it goes
- Works through AZD setup, generated provider YAML, test gates, environment variables, and Kubernetes adaptations; defers further provider configuration to documentation.
- Examples
- Uses GitHub Actions and Azure DevOps YAML workflows with added tests, plus provider-specific Kubernetes pipeline examples.
- What you can do after
- Operate/configure an AZD-generated Aspire pipeline, add a test gate, and adapt its deployment steps for Kubernetes.
Read how Building Distributed Applications that Work explains deployment pipeline →
gRPC Microservices in Go
A CI/CD pipeline is an automated software-delivery workflow that integrates, tests, and prepares or deploys changes continuously.
- How it is used
- Automates generation, verification, and preparation of Go gRPC microservices for deployment to Kubernetes.
- How deep it goes
- Details a tagged, matrix-based stub-generation workflow and recommends release checks and rollout methods, without specifying a complete deployment job.
- Examples
- Uses a GitHub Actions workflow and Bash script to generate tagged Go stubs for order, payment, and shipping services.
- What you can do after
- Operate/configure it to generate versioned service stubs, verify changes, and plan artifact promotion with rollback readiness.
Read how gRPC Microservices in Go explains deployment pipeline →
Authorization in Action
A CI/CD pipeline is an automated workflow that builds, tests, and delivers software or configuration changes through continuous integration and continuous delivery.
- How it is used
- Automates checks and delivery so reviewed authorization changes reach runtime enforcement repeatably.
- How deep it goes
- Traces pull requests through schema validation, static analysis, tests, signed bundling, publication, and runtime retrieval.
- Examples
- Uses pull-request checks to catch misspelled actions, missing schema attributes, and failing behavior tests before deployment.
- What you can do after
- Operate a repeatable policy-release workflow with automated checks, reviewed changes, versioned bundles, and runtime publication.
Read how Authorization in Action explains deployment pipeline →
Kafka for Architects
A continuous integration/continuous deployment pipeline is an automated workflow that validates, builds, tests, and delivers software or infrastructure changes.
- How it is used
- Automates Kafka infrastructure changes by reconciling cluster configuration with declarative state stored in Git.
- How deep it goes
- Explains Git-triggered reconciliation and drift checks, but does not detail pipeline implementation.
- Examples
- Uses Kafka cluster configuration changes and an AsyncAPI-to-Kafka resource workflow for a Customer 360 ODS.
- What you can do after
- Operate/configure Kafka infrastructure by generating resources from AsyncAPI definitions and synchronizing the cluster with Git.
Read how Kafka for Architects explains deployment pipeline →
Machine Learning Platform Engineering
Continuous integration is a software-development practice that automatically builds and verifies changes as they are integrated into a shared codebase.
- How it is used
- Automates application testing and deployment, or supports continuous delivery of retrained ML models to prediction services.
- How deep it goes
- Explains three GitLab CI stages and their jobs, and identifies modular components, validation, monitoring, and triggers for ML pipelines.
- Examples
- Uses a FastAPI application pipeline that tests Python code, builds and pushes a Docker image, and updates a Helm chart.
- What you can do after
- Build a GitLab CI configuration that tests code, publishes a Docker image, and updates a Helm chart.
Read how Machine Learning Platform Engineering explains deployment pipeline →
Delivering Machine Learning Projects: From design to deployment
CI/CD is the practice of automating continuous integration, testing, and delivery or deployment of software changes.
- How it is used
- Automates production promotion and verifies the release with post-release tests.
- How deep it goes
- Details artifact transfer, test planning and execution, and contingency readiness, but not pipeline configuration.
- Examples
- Uses Jenkins, button- or command-triggered releases, and automated post-release tests as examples.
- What you can do after
- Operate/configure it by automating artifact promotion, planning release tests, and preparing responders for deployment failures.
Learn Go with Pocket-Sized Projects
Continuous integration is a software development practice in which changes are automatically built and tested when integrated into a shared codebase.
- How it is used
- Separates lightweight pull-request checks from slower tests that may run during tagging and image building.
- How deep it goes
- Shows how `go test -short` sets `testing.Short()` and skips integration tests, but does not detail CI-system configuration.
- Examples
- Uses a gRPC habits service to test creation, listing, invalid input, and generated IDs.
- What you can do after
- Configure Go integration tests to skip in lightweight runs with `-short`, reserving heavier checks for later runs.
Read how Learn Go with Pocket-Sized Projects explains deployment pipeline →
Microsoft Azure in Action
CI/CD is the practice of automatically integrating, testing, and delivering software changes through a repeatable pipeline.
- How it is used
- Moves validated AI models from staging toward production through repeatable promotion workflows.
- How deep it goes
- Details approval gates, smoke tests, rollout strategies, and monitoring, but leaves pipeline implementation out of scope.
- Examples
- Uses Banning Books recommendation and cover-classifier models, with staging tests and canary or blue/green rollouts.
- What you can do after
- Configure AI Foundry model promotions with staging checks, approval gates, rollout strategies, and monitoring.
Read how Microsoft Azure in Action explains deployment pipeline →
Machine Learning System Design
A set of continuous integration and continuous delivery or deployment practices that automate software integration, testing, and release.
- How it is used
- Connects integration checks and artifact packaging with the practical work of releasing software and machine-learning systems.
- How deep it goes
- Describes CI checks, model packaging, and operational safeguards, without detailing deployment orchestration.
- Examples
- Names unit and integration tests, test deployments, ONNX and CoreML models, JSON configuration, and validation reports.
- What you can do after
- Evaluate release checks and package formats that reduce coupling between training and deployment.
Read how Machine Learning System Design explains deployment pipeline →
Build a Frontend Web Framework (From Scratch)
The process of transforming application source code and assets into files prepared for delivery to users.
- How it is used
- Prepares frontend application files for delivery before deployment to production.
- How deep it goes
- Outlines template compilation, bundling, minification, and HTML output, while treating the process as a simplified set of common practices.
- Examples
- Uses app.bundle.js, vendors.bundle.js, bundle.css, and index.html as example build outputs.
- What you can do after
- Apply it via a framework CLI, commonly invoked with an npm run build script, to prepare files for delivery.
Read how Build a Frontend Web Framework (From Scratch) explains deployment pipeline →
Introduction to Generative AI, Second Edition
CI/CD is the practice of automating continuous integration, testing, delivery, and deployment of software changes.
- How it is used
- Positions CI/CD as a DevOps workflow where AI agents can support operational tasks.
- How deep it goes
- Describes agent-assisted monitoring, test-failure fixes, deployment rollback, and performance triage without implementation details.
- Examples
- Illustrates agents suggesting fixes for failing tests, rolling back deployments, and triaging performance issues.
Read how Introduction to Generative AI, Second Edition explains deployment pipeline →
Build Python Web Apps with Streamlit
Continuous integration is the practice of automatically validating code changes as they are integrated into a shared codebase.
- How it is used
- Automates test runs as code changes are committed or pushed, helping catch problems early.
- How deep it goes
- Shows a pre-commit hook and mentions pre-push hooks and GitHub Actions, but gives no CI-service configuration.
- Examples
- Uses a Git pre-commit hook for non-API tests and names pre-push hooks and push-triggered GitHub Actions.
- What you can do after
- Operate automated checks with Git hooks or CI runs on pushes, blocking failing commits or notifying teams of failures.
Read how Build Python Web Apps with Streamlit explains deployment pipeline →
Also covered in
- GitHub Actions in Action: Continuous integration and delivery for DevOps
- Lead Developer Career Guide
- "Looks Good to Me"
- Snowflake Data Engineering
- Contract Testing in Action
- AI-Powered Developer: Build software with ChatGPT and Copilot
- Data Pipelines with Apache Airflow, Second Edition
- .NET MAUI in Action
- Software Security for Developers
- Build High Value Software SystemsIn early access (MEAP)
- AI for Everyday IT
- ASP.NET Core in Action, 3e
What to know first
- software testingSoftware testing is the systematic evaluation of software under specified inputs or conditions to assess its behavior against expected results or requirements and identify defects.
- productionProduction is the live operational setting in which a deployed software system serves its intended users or processes real workloads.
- versioningVersioning is the practice of assigning or maintaining identifiable revisions of artifacts over time so their changes, histories, or compatibility can be tracked.
- containerA software container is an isolated execution environment that packages an application and its dependencies, typically sharing the host operating-system kernel.
Related concepts
- software artifactproduces · A software artifact is a persistent work product or object produced, maintained, or consumed during software development or operation.
- test suiteuses · A test suite is an organized collection of tests that can be executed together to assess a software system or model against specified behaviors or criteria.
- software testinguses · Software testing is the systematic evaluation of software under specified inputs or conditions to assess its behavior against expected results or requirements and identify defects.
- GitHub Actionsused by · GitHub Actions is GitHub’s workflow automation platform for defining and running jobs in response to repository events, schedules, and other triggers.
- container imageproduces · A container image is a packaged filesystem and metadata artifact from which a container can be created and run.
- integration testuses · An integration test evaluates whether multiple software components, or a component and an external dependency, interact and behave correctly together.
Questions about deployment pipeline
What is deployment pipeline?
A deployment pipeline is a repeatable sequence of stages that builds, tests or validates, packages, and delivers software changes toward release or deployment.
Which Manning books explain deployment pipeline?
Platform Engineering on Kubernetes, Bootstrapping Microservices, Second Edition: With Docker, Kubernetes, GitHub Actions, and Terraform, Effective Platform Engineering, Learn Docker in a Month of Lunches, Second Edition, Microservices Patterns, Second Edition, Spring Microservices in Action, Automating API Delivery, Terraform in Depth: Infrastructure as Code with Terraform and OpenTofu and 29 more.
What should I know before learning deployment pipeline?
Manning books that teach deployment pipeline usually introduce software testing, production, versioning and container first.
What is deployment pipeline also called?
Deployment pipeline is also called CI/CD pipeline.
These guides are generated from the text of Manning books by Manning's knowledge graph and link to the sections they draw on. The full books are available on liveBook and at manning.com.




































