Skip to content
academia.sh
tr
Log in

Course Intermediate

Continuous Integration and Delivery

Published Updated

By the end of this course

Start course

01

Pipeline Design

Building the gates on a change's path to production: frequent merging's effect on conflict and feedback, the separation of continuous delivery from continuous deployment, the defects the build, test, packaging, and release gates hold and miss, versioning and retaining the build artifact, the limit on shortening pipeline time with caching and parallelism, the cost of managed and self-hosted runners, the pipeline's declarative definition, and event, schedule, and manual triggering.

  1. 01 Continuous Integration Scanning the merge interval: how conflicting files, resolution rounds, and errors born in resolution grow as the interval grows, how many runs and how many runner minutes frequency's own cost takes, and what the merge gate alone catches and how many clean changes it stops for nothing.
  2. 02 Continuous Delivery and Continuous Deployment Running the same pipeline in two modes: the difference between every green run being production-ready (delivery) and every green run being in production (deployment) is measured by the change reaching production, the number of people deciding, the wait time, and the real defects manual approval catches; the approval's marginal value is tied to batch size.
  3. 03 Pipeline Stages Measuring the build, test, packaging, and release gates with a known defect set: what each gate holds, what it alone holds, what it passes, and what it stops for nothing are counted, the time it adds is written in runner minutes, and each of the eight gates is removed one at a time to find the gate whose removal is better.
  4. 04 Build Artifact Management The version identity and retention rule of the pipeline's output: the uniqueness of six identity schemes and their rate of resolving back to source are measured, and seven retention rules are scanned to count the rollback window, unbroken depth, and wastefully retained output together.
  5. 05 Caching and Parallelism The pipeline's own duration is measured: stage caching derives a key from the content hash of real files, a twelve-run sequence counts cached and uncached duration, hit rate, and the hit rate's distribution by change type, and then parallelism is applied to show the limit the critical path sets.
  6. 06 Pipeline Runners The same pipeline runs on two runner types: queue wait, the cost line item per run, whether the cache persists between runs, and the maintenance line item are counted, the number of runs a day after which each type gets cheaper is calculated, and the items the measure leaves out are named.
  7. 07 Pipeline as Code The same pipeline is defined in two forms — by hand through an interface and as a file in the repository: a schema is defined within the lesson and six faulty changes are run through a real validator, and traceability, the fraction of pipeline changes that pass without review, the rollback step, and the line cost of duplicating the definition are counted.
  8. 08 Triggers Event, schedule, and manual triggering are all run on the same two-week fictional calendar: run count, wasted runs made when nothing has changed or when a change does not affect the pipeline's output, the delay between a change and its run, and overlapping runs are counted, and then a path-based filter is added and the drop in wasted runs is measured together with the real change it misses.

02

Release Strategies

How the same artifact enters production: branching strategy's relationship to integration frequency, the same artifact being promoted across environments, the balance that staged rollout strikes between escaped defects and affected requests, two-environment deployment's instant-rollback capability and its cost, feature flags separating deployment from release and the flag debt that accumulates, how many steps a rollback plan runs, and coordinating the ordering of database migrations.

  1. 01 Branching Strategy and Pipeline Relationship Long-lived branching and trunk-based development run on the same ninety-change stream: branch lifetime, conflicting files, gate runs per integration, and when the integration gate runs under each scheme are counted. Trunk-based development's own cost — the concealment record — is measured separately.
  2. 02 Environment Promotion The scheme where the same build artifact promotes between environments is run against the scheme where every environment rebuilds, on the same forty-candidate sequence: environment-specific defects, what the promotion gate catches, whether the artifact's identity is preserved across environments, and how long an artifact waits at the promotion gate are counted.
  3. 03 Staged Rollout The decision side of percentage rollout is measured: the metric that raises the percentage, the metric window, and the decision threshold are scanned. Across three ladders, the stop rate for pronounced and faint defects, touched requests, the wrongful rollback of a clean version, and total rollout duration are counted.
  4. 04 Two-Environment Deployment Rollback's round cost and the standing bill of keeping two full environments up are counted together: the rollback window is scanned, sessions and long-running jobs cut off at the moment of cutover are measured, and the rows that rollback fails to undo in the shared data layer are shown.
  5. 05 Feature Flags The same change sequence is released under two schemes, with and without flags; whether the rollback unit is code or behavior is measured in rounds and affected invoices. The eight code paths opened by three flags are counted, the tested-path share is derived, and a period's flag debt is written down together with its dead code paths.
  6. 06 Rollback Plan Rollback is modeled not as a button but as a plan: three scenarios (code only, code and config, code and data) are run step by step, every step's round is counted, and which step is the point of no return is found. How many steps an unrehearsed plan gets stuck on during its first run, and the precondition check's value as a gate, are measured.
  7. 07 Coordination with Database Migrations Six migration types are actually applied and reversed, and reversibility is measured not by whether the command runs without error but by whether the table's content comes out identical. The expand–migrate–contract scheme runs step by step; at every step, whether the old and new versions can run together is counted, and the incompatible step's effect on the release window and the rollback plan is written down.

03

Repository-Based Deployment and the Supply Chain

Keeping the desired state in version control and verifying the source of the output: the repository-defined desired state principle, pull-based deployment with an in-cluster reconciler agent, approaches to storing sealed secrets in the repository, generating the dependency inventory, signing and verifying the build artifact, least-privileged identities, and the pipeline's own security with an isolated build environment.

  1. 01 Repository-Defined Desired State The same change flow runs in two arrangements — manual application and committing to the repository — and across 180 changes the two arrangements' traceability, unrecorded-change rate, end-of-period drift, and steps per change are counted. The review gate's marginal value — the defect it alone catches, the clean change it wrongly holds, and the 796 hours it adds — is measured separately.
  2. 02 Pull-Based Deployment Two arrangements that carry the desired state from the repository to the cluster — the pipeline writing to the cluster and an in-cluster agent reading the repository — are counted on the same items: authority surface, connection direction, the detection delay of a manual drift, and what happens when the pipeline goes down. The reconciliation round's marginal value comes out to 17 drifts, and the genuine intervention it wrongly reverts to 9.
  3. 03 Secret Management When secrets are kept sealed in the repository, where the key sits, how many subjects can decrypt how many records, and how many records get re-encrypted and how many files get touched when the key is rotated, are counted with real encryption. A sealed record's staying in the past is measured: if the old key leaks, 24 versions in history decrypt and 11 are today's value.
  4. 04 Software Bill of Materials The components inside a build artifact are produced as an inventory and measured with three numbers: the direct, transitive, and build-time components the inventory sees, the three classes it never sees at all, and how many queries the response takes when a defect advisory arrives.
  5. 05 Build Artifact Signing and Verification The chain running from the source commit to the deployed output is built with a real key pair, and two questions are turned into numbers: however many forged outputs get through depends on the point in the chain where verification happens, and how many subjects with access to that key can sign.
  6. 06 Pipeline Security The pipeline itself is measured: how many secrets and targets nine job steps reach, the access that drops and the cost paid when moving to least privilege, the state carried between jobs run back to back on the same runner, and, across a known set of misuse attempts, what each constraint closes, misses, and how much legitimate work it stops.

Final exam

Continuous Integration and Delivery — Final Exam

In preparation

This course's question bank is not complete yet. The exam opens here automatically once enough questions are added.

Start typing to search.

↑↓ ↵ Esc navigate · open · close