GuideIntermediate
Cicd And Gitops On Aws
This guide takes the Andes Cargo Terraform project, finished by hand in the Terraform and IaC Guide, and teaches you to stop running `terraform apply` from your laptop and start running it inside a pipeline. It distinguishes continuous integration, continuous delivery, and continuous deployment, defines GitOps (Git as the source of truth for infrastructure, not just code), and dissects the full anatomy of a GitHub Actions workflow. It builds the industry-standard pattern — `fmt`/`validate`/`plan` run on every Pull Request as the artifact reviewed before merging, and `apply` run automatically only when that PR merges to `main` — covers secrets management and why a long-lived AWS credential in a repository is the most-cited security antipattern in the market, shows the federated OIDC pattern in real YAML, and teaches approval environments, concurrency control, and scheduled drift detection. The rollback module teaches the infrastructure-specific pattern (revert the commit, let the same pipeline re-apply) and builds a real guardrail that fails the job if a change tries to destroy Andes Cargo's data table — revisiting the real `terraform destroy` incident from the previous guide by asking whether a pipeline would have prevented it. Everything runs $0 and reproducibly with `act`, the tool that executes real GitHub Actions YAML in local Docker, against the same LocalStack lab from the previous guides — with explicit honesty about what `act` cannot simulate (environment approvals, branch protection, real PR comments), each labeled at the exact point it appears.
- 64
- lessons
- 8
- modules
- English · Spanish
- available in
- Yes
- certificate
- Free
- access
Outcomes
What you'll be able to do
- Distinguish continuous integration, continuous delivery, and continuous deployment, and place each piece of an infrastructure pipeline correctly
- Explain what GitOps is and why Git becomes the source of truth for infrastructure, not just a code history
- Write and read the full anatomy of a GitHub Actions workflow (`on`/`jobs`/`steps`/`runs-on`/`uses`/`with`), with its triggers (`push`, `pull_request`, `schedule`, `workflow_dispatch`)
- Build the `fmt`/`validate`/`plan` pattern on every Pull Request as the artifact reviewed before merging an infrastructure change
- Chain an automatic `apply` on merge to `main`, using `needs` and the exact plan that was reviewed, without recomputing it
- Handle secrets with GitHub Secrets and explain why a long-lived credential in a repository is an antipattern, with federated OIDC as the modern alternative
- Configure concurrency control to prevent a simultaneous double `apply` against the same state
- Schedule drift detection with `schedule` and cron syntax
- Apply the infrastructure rollback pattern (revert the commit, let the pipeline re-apply) and use branch protection as a merge control
- Build a guardrail that inspects a JSON `plan` and fails the pipeline before a protected resource gets destroyed
- Run GitHub Actions workflows locally with `act`, simulating events and passing secrets without depending on a real GitHub account
Before you start
What you need to bring
It's for you if...
- Devs who already completed the Terraform and IaC Guide and want to stop running `apply` by hand from their laptop
- Teams that need mandatory review before an infrastructure change reaches production
- Devs looking to replace long-lived AWS credentials stored in a repository with a more secure pattern
- Anyone who needs the standard CI/CD pattern for infrastructure as code (not application code) before building advanced security guardrails
Requirements and materials
- Terraform and IaC Guide completed (the `andes-cargo-infra/` project, the `init`/`plan`/`apply`/`destroy` cycle, reusable modules)
- Practical Git usage: `init`/`add`/`commit`/`branch`/`merge`/`revert`
- Docker installed and running locally (to run `act` and LocalStack)
- Free LocalStack account with an auth token, no credit card or real GitHub account needed
Content
The syllabus, module by module
Open any of them to see its lessons.
- 1. Introduction to the guide: from the terminal to the pipeline
- 2. The trouble with manual `apply`
- 3. CI, CD, and CD: three things, one acronym
- 4. What is GitOps
- 5. GitHub Actions and its alternatives, with market honesty
- 6. Hands-on: installing `act`
- 7. Hands-on: your first local workflow, end to end
- 8. Project: bootstrapping Andes Cargo's pipeline
- 1. Introduction: reading and writing a workflow with judgment
- 2. A workflow block's complete anatomy
- 3. Triggers: `push`, `pull_request`, `workflow_dispatch`
- 4. The `schedule` trigger and cron syntax
- 5. Reusable Actions: `uses`, `with`, and the supply-chain risk
- 6. Hands-on: simulating events with `act -e`
- 7. Hands-on: passing secrets to `act`
- 8. Project: Andes Cargo's first real workflow
- 1. Module introduction: what runs before merging
- 2. The HashiCorp/GitHub pattern: `plan` on PR, `apply` on merge
- 3. Installing Terraform inside an ephemeral runner
- 4. Hands-on: `fmt` and `validate` as steps that can fail the job
- 5. Connecting the runner to LocalStack through the host
- 6. Hands-on: `terraform plan` running inside CI
- 7. Publishing the `plan` as review evidence
- 8. Project: Andes Cargo's `ci.yml`
- 1. Introduction: who can apply what, and with which key
- 2. Why credentials never belong in the repository
- 3. GitHub Secrets: repo-scoped and environment-scoped
- 4. What is OIDC federation
- 5. The OIDC pattern in YAML, named
- 6. GitHub Environments: `dev` and `prod`
- 7. Hands-on: dummy credentials for LocalStack
- 8. Project: Andes Cargo's secrets and environments plan
- 1. Introduction: from review to apply
- 2. The merge trigger: `push` to `main`
- 3. Chaining jobs with `needs` and passing the exact `plan`
- 4. Hands-on: building `apply.yml`
- 5. Concurrency control: avoiding the double `apply`
- 6. Scheduled drift detection
- 7. Hands-on: running the drift job manually
- 8. Project: Andes Cargo's full plan-to-apply pipeline
- 1. Introduction: what to do when the `apply` goes wrong
- 2. What rollback means for infrastructure
- 3. Hands-on: the `git revert` pipeline
- 4. Branch protection as a control
- 5. Would a pipeline have stopped the Claude Code incident?
- 6. Guardrails of `apply`, named
- 7. Hands-on: a minimal, real, executed guardrail
- 8. Project: Andes Cargo's safety net
- 1. Module 7 introduction: what this guide is not
- 2. GitLab CI, CircleCI, and Jenkins by contrast
- 3. GitOps for Kubernetes: ArgoCD and Flux, named
- 4. *Push-based* vs. *pull-based*: two GitOps, one principle
- 5. Application deployment strategies, named
- 6. CI/CD for application code vs. infrastructure
- 7. Hands-on: a minimal application pipeline, just for contrast
- 8. Project: Andes Cargo's tooling decision
- 1. Capstone introduction: the complete pipeline, end-to-end
- 2. Architecture review: the complete pipeline
- 3. End-to-end walkthrough: a real change crossing the pipeline
- 4. End-to-end walkthrough: a rejected change
- 5. What only a real GitHub account shows
- 6. The security this guide didn't build
- 7. What Andes Cargo still needs
- 8. Final project: the Andes Cargo pipeline as a deliverable
Common questions
What people usually ask
No limit. It's a free guide: come in whenever you like, as often as you like.
No. Modules run from easier to harder, but you can jump to the one you need. Progress is saved per lesson.
Whatever is needed is listed under “What you need to bring”, above. If nothing is listed there, you can start from zero.
In the Club's WhatsApp group, and every two weeks there's a live with an instructor where questions get worked through.
Yes. It's issued automatically once you finish every lesson, with a verifiable code you can share on LinkedIn.
Start whenever you like
What students say
These reviews are from enrolled students who completed at least 50% of the course. We moderate reviews only on content grounds (spam, offensive language, personal data), never for being critical or negative.
No approved reviews yet.
Be the first to share your experience!