Day 21 - CI/CD Fundamentals

Day 21 - CI/CD Fundamentals



Tópico: Day 21 - CI/CD Fundamentals
Categoria: Tutoriais | Programação & Tecnologia
Idioma Principal: Português (Conteúdo de Tecnologia)

Descrição do Conteúdo / Informações:
-------------------------------------------------------------------------
Modern software development moves incredibly fast.

A single application may receive:

• Hundreds of commits daily

• Multiple releases per week

• Thousands of automated tests

• Continuous security scans

Imagine manually building, testing, and deploying every code change.

It would look like:

Developer Writes Code
↓
Manual Build
↓
Manual Testing
↓
Manual Deployment
↓
Production Issues

This approach doesn't scale.

This is why CI/CD became one of the most important practices in modern DevOps.



🔗 Resources


• ** Support the Journey on GitHub:
If you're following along, consider starring and forking the repo:**
https://github.com/17J/30-Days-Cloud-DevSecOps-Journey



What is CI/CD?


CI/CD stands for:

Continuous Integration
Continuous Delivery / Continuous Deployment

CI/CD is a software engineering practice that automates:

• Building applications

• Running tests

• Security scanning

• Packaging artifacts

• Deploying applications

The goal is simple:

Deliver Software Faster
+
Safer
+
More Reliably



Why CI/CD Matters


Before CI/CD, software releases often looked like:

Developers Work for Weeks
↓
Massive Release
↓
Unexpected Issues
↓
Rollback

Common problems:

• Human errors

• Slow deployments

• Integration conflicts

• Unstable releases

• Delayed feedback

CI/CD solves these challenges through automation.



The Evolution of Software Delivery


Manual Deployments
↓
Build Automation
↓
Continuous Integration
↓
Continuous Delivery
↓
GitOps
↓
Platform Engineering

Modern organizations rely heavily on CI/CD.



What is Continuous Integration (CI)?


Continuous Integration is the practice of frequently merging code into a shared repository.

Every code change triggers:

Git Commit
↓
Build
↓
Tests
↓
Security Scans
↓
Feedback

Developers receive immediate feedback.



Why Continuous Integration?


Without CI:

Developer A
↓
Developer B
↓
Developer C
↓
Massive Merge Conflict

With CI:

Small Changes
↓
Frequent Integration
↓
Early Problem Detection



Benefits of Continuous Integration




Faster Feedback


Developers immediately know if code breaks.



Better Code Quality


Automated testing catches bugs earlier.



Fewer Integration Problems


Small changes are easier to merge.



Improved Team Collaboration


Everyone works from a shared codebase.



What is Continuous Delivery?


Continuous Delivery ensures applications are always ready for release.

Pipeline example:

Code Commit
↓
Build
↓
Test
↓
Security Scan
↓
Package
↓
Deploy to Staging
↓
Ready for Production

A human approval step may still exist before production deployment.



What is Continuous Deployment?


Continuous Deployment goes one step further.

Code Commit
↓
Build
↓
Test
↓
Security Scan
↓
Production Deployment

No manual approval required.

Every successful change reaches production automatically.



Modern CI/CD Architecture


Today's delivery pipelines look different from five years ago.

Traditional:

CI Tool
↓
Build
↓
Deploy

Modern:

CI Pipeline
↓
Container Registry
↓
GitOps Repository
↓
ArgoCD / Flux
↓
Kubernetes

GitOps has fundamentally changed CD.



Mostly CI Pipeline Stages


Modern CI pipelines usually contain:



Stage 1: Source Code


Developer Commit
↓
GitHub / GitLab / Bitbucket

Pipeline starts.



Stage 2: Secret Scanning


Detect:

• API Keys

• Tokens

• Passwords

Popular tools:

• Gitleaks

• TruffleHog



Stage 3: Build


Compile application.

Examples:

mvn package
npm run build
dotnet build



Stage 4: Unit Testing


Verify application logic.

Examples:

JUnit
PyTest
Jest
NUnit



Stage 5: Static Security Testing


SAST Scans:

Source Code

Popular tools:

• SonarQube

• Semgrep

• Checkmarx



Stage 6: Software Composition Analysis


Checks dependencies.

Popular tools:

• Snyk

• Trivy

• OWASP Dependency Check



Stage 7: Container Build


Docker Build

Creates application image.



Stage 8: Container Security Scan


Scan images for vulnerabilities.

Popular tools:

• Trivy

• Grype

• Dockle



Stage 9: Push Artifact


Push:

Docker Hub
ECR
ACR
GCR
Harbor
Nexus



Stage 10: Update GitOps Repository


Instead of deploying directly:

Update Manifest Repository

Example:

image:
tag: v1.5.0

Commit changes.



Modern CD with GitOps


Today many organizations use:

CI Tool
↓
Build
↓
Push Image
↓
Update Git Repository
↓
GitOps Controller
↓
Deploy

This separates CI from CD.



Why GitOps Became Popular


Traditional CD:

Pipeline Pushes Changes

GitOps:

Cluster Pulls Changes

Benefits:

• Better security

• Auditability

• Rollback simplicity

• Declarative deployments



Popular GitOps Tools




ArgoCD


One of the most popular GitOps platforms.

Features:

• Kubernetes-native

• Visual dashboard

• Automatic synchronization

• Rollbacks

• Multi-cluster support

Architecture:

Git Repository
↓
ArgoCD
↓
Kubernetes Cluster



FluxCD


Another GitOps platform.

Features:

• Lightweight

• Kubernetes-native

• CNCF graduated project

Architecture:

Git Repository
↓
Flux Controller
↓
Kubernetes



Popular CI/CD Platforms




Jenkins


The most popular traditional CI/CD platform.

Benefits:

• Open source

• Huge plugin ecosystem

• Highly customizable

Best for:

Complex Enterprise Pipelines



GitHub Actions


Native CI/CD for GitHub.

Example:

name: Build

on:
push:

jobs:
build:
runs-on: ubuntu-latest

Benefits:

• Easy setup

• GitHub integration

• Marketplace actions



GitLab CI/CD


Built directly into GitLab.

Example:

stages:
- build
- test

Benefits:

• Integrated DevOps platform

• Strong Kubernetes support



Azure DevOps


Microsoft's enterprise DevOps platform.

Features:

• Pipelines

• Boards

• Repositories

• Artifacts

Popular in enterprise environments.



Bitbucket Pipelines


Integrated with Bitbucket repositories.

Example:

pipelines:
default:
- step:
script:
- npm install



CircleCI


Cloud-native CI/CD platform.

Popular among startups.



TeamCity


JetBrains CI/CD solution.

Common in enterprise Java environments.



Bamboo


Atlassian's CI/CD platform.

Used alongside:

• Jira

• Bitbucket

• Confluence



CI/CD in Kubernetes Era


Modern Kubernetes pipelines often look like:

Developer Commit
↓
GitHub Actions / Jenkins
↓
Build Container
↓
Security Scans
↓
Push Image
↓
Update GitOps Repository
↓
ArgoCD / Flux
↓
Kubernetes Deployment

This model has become the industry standard.



DevSecOps in CI/CD


Modern pipelines integrate security at every stage.

Example:

Commit
↓
Secret Scan
↓
SAST
↓
SCA
↓
Container Scan
↓
IaC Scan
↓
Deploy

Security is no longer a separate phase.



CI/CD Best Practices




Keep Pipelines Fast


Developers should receive feedback quickly.



Automate Testing


Manual testing does not scale.



Integrate Security Early


Shift security left.



Use GitOps for CD


Prefer:

ArgoCD
FluxCD

for Kubernetes deployments.



Version Everything


Store:

• Source code

• Infrastructure

• Kubernetes manifests

inside Git.



Monitor Deployments


Deployment success is not enough.

Monitor:

• Performance

• Errors

• Availability



Real-World Pre Prod Enterprise Pipeline




Future of CI/CD


The industry is moving toward:

• GitOps

• Platform Engineering

• AI-assisted pipelines

• Policy as Code

• Progressive Delivery

• Automated Compliance

• Zero-Touch Deployments

The future isn't just CI/CD.

It's:

Secure
Automated
GitOps-Driven
Cloud-Native Delivery



Final Thoughts


CI/CD has transformed how software is delivered.

Instead of:

Manual Builds
Manual Tests
Manual Deployments

we now have:

Automated Builds
Automated Testing
Automated Security
Automated Delivery

Modern organizations typically use:



CI


• Jenkins

• GitHub Actions

• GitLab CI

• Azure DevOps

• Bitbucket Pipelines



CD (GitOps)


• ArgoCD

• FluxCD

Together, these tools enable faster releases, higher quality software, stronger security, and reliable cloud-native deployments.

Whether you're a:

• DevOps Engineer

• Platform Engineer

• Cloud Engineer

• SRE

• Software Developer

understanding CI/CD fundamentals is one of the most valuable skills in modern software engineering.