Skip to content

doug-cpp-devsecops/nodegoat

BranchesTags

Repository files navigation

Manual do Aluno - Laboratório DevSecOps

Guia prático para configuração do ambiente e execução dos laboratórios.

📝 Convenção de Nomes: Ao longo deste manual, usamos <seu-nome>-nodegoat como exemplo de nome para o repositório pessoal (ex: joao-nodegoat, maria-nodegoat). Você pode escolher o nome que preferir para seu repositório, mas recomendamos seguir este padrão para facilitar a identificação.

⚠️ IMPORTANTE - Usuários Windows

Se você usa Windows, configure o WSL 2 ANTES de continuar.

👉 Vá para: Apêndice A: Configuração do WSL 2

Após configurar, volte para a Seção 1.

⚠️ NOTA IMPORTANTE: Após configurar o WSL 2, você deve trabalhar SEMPRE dentro do ambiente WSL durante toda a disciplina. Para iniciar o WSL, abra o PowerShell ou CMD e digite:

wsl

Todos os comandos e ferramentas devem ser executados dentro do terminal WSL (Ubuntu), não no Windows nativo.

⚠️ IMPORTANTE - Diretório de Trabalho (WSL): Sempre trabalhe no diretório home do usuário WSL:

cd ~

Não trabalhe nos diretórios montados do Windows (/mnt/c/), pois isso causa problemas de performance e permissões. Clone os repositórios diretamente no home do WSL (~).

Índice

  1. Instalação Inicial
  2. Configuração do GitHub
  3. Setup do Repositório
  4. Pre-commit Hooks
  5. Kubernetes Local
  6. GitHub Actions Runner
  7. Workflow 00 - Debug
  8. Workflow 01 - Secret Scanning
  9. Workflow 02 - SCA
  10. Workflow 03 - SAST
  11. Workflow 04 - Container Scanning
  12. Workflow 05 - IaC Scanning
  13. Workflow 06 - Build e Deploy
  14. Referência Rápida
  15. Apêndice A: Configuração do WSL 2

1. Instalação Inicial

⚠️ SUPER IMPORTANTE - Variáveis de Ambiente:

Para facilitar os comandos ao longo do laboratório, crie variáveis com os caminhos dos repositórios:

# Repositório do instrutor (já existe)
export INSTRUCTOR_REPO=~/nodegoat

# Seu repositório pessoal (será criado na seção 2.2)
# Substituir <seu-nome>-nodegoat pelo nome escolhido
export STUDENT_REPO=~/<seu-nome>-nodegoat

# Exemplo: export STUDENT_REPO=~/joao-nodegoat

# Para tornar permanente, adicionar ao ~/.bashrc ou ~/.zshrc:
echo 'export INSTRUCTOR_REPO=~/nodegoat' >> ~/.bashrc
echo 'export STUDENT_REPO=~/<seu-nome>-nodegoat' >> ~/.bashrc
source ~/.bashrc

# macOS (se usar zsh):
echo 'export INSTRUCTOR_REPO=~/nodegoat' >> ~/.zshrc
echo 'export STUDENT_REPO=~/<seu-nome>-nodegoat' >> ~/.zshrc
source ~/.zshrc

Todos os comandos a seguir usarão $INSTRUCTOR_REPO e $STUDENT_REPO.

Nota: O repositório pessoal será criado no GitHub na Seção 2.2 e clonado localmente na Seção 3.1.

1.1 Instalar Homebrew (macOS)

⚠️ Apenas para macOS

# Verificar se já está instalado
brew --version

# Se não estiver instalado:
/bin/bash -c "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/HEAD/install.sh)"

# Seguir instruções na tela para adicionar ao PATH

1.2 Instalar Just

# macOS
brew install just

# Linux/WSL
sudo apt update && sudo apt install -y just

1.3 Instalar Docker

macOS:

Windows:

  • Baixar Docker Desktop para Windows
  • Durante instalação: marcar "Use WSL 2 instead of Hyper-V"
  • Após instalação:
    • Abrir Docker Desktop
    • Settings → Resources → WSL Integration
    • Habilitar integração com Ubuntu

Linux:

Documentação oficial: https://docs.docker.com/engine/install/ubuntu/

# Remover versões antigas (se houver)
sudo apt remove docker docker-engine docker.io containerd runc

# Instalar dependências
sudo apt update
sudo apt install -y ca-certificates curl gnupg lsb-release

# Adicionar chave GPG oficial do Docker
sudo mkdir -p /etc/apt/keyrings
curl -fsSL https://download.docker.com/linux/ubuntu/gpg | sudo gpg --dearmor -o /etc/apt/keyrings/docker.gpg

# Adicionar repositório Docker
echo \
  "deb [arch=$(dpkg --print-architecture) signed-by=/etc/apt/keyrings/docker.gpg] https://download.docker.com/linux/ubuntu \
  $(lsb_release -cs) stable" | sudo tee /etc/apt/sources.list.d/docker.list > /dev/null

# Instalar Docker Engine
sudo apt update
sudo apt install -y docker-ce docker-ce-cli containerd.io docker-buildx-plugin docker-compose-plugin

# Adicionar usuário ao grupo docker
sudo usermod -aG docker $USER
newgrp docker

# Iniciar serviço
sudo systemctl enable docker
sudo systemctl start docker

Verificar:

docker --version
docker compose version

1.4 Clonar Repositório e Instalar Ferramentas

# Ir para o diretório home
cd ~

# Clonar repositório do instrutor (será o $INSTRUCTOR_REPO)
git clone https://github.com/cesar-devsecops-2025/nodegoat
cd nodegoat

# Ou usar a variável:
# git clone https://github.com/cesar-devsecops-2025/nodegoat $INSTRUCTOR_REPO
# cd $INSTRUCTOR_REPO

# Instalar TODAS as ferramentas automaticamente
just setup

O que just setup instala:

  • Git
  • kubectl (Kubernetes CLI)
  • pre-commit (hooks framework)
  • kind (Kubernetes in Docker)
  • helm (package manager)
  • kubectx/kubens (context switcher)
  • k9s (TUI manager)

⚠️ Linux/WSL - PATH do pipx:

# Se pre-commit não for encontrado
source ~/.bashrc
# ou reiniciar terminal

Configurar Git:

git config --global user.name "Seu Nome"
git config --global user.email "seu@email.com"

2. Configuração do GitHub

2.1 Criar Organização

  1. GitHub → Settings → Organizations → New organization
  2. Organization Settings → Actions → General
  3. Selecionar: "Allow all actions and reusable workflows"

2.2 Criar Repositório Pessoal

  1. Na organização criada, clicar em "New repository"
  2. Nome: <seu-nome>-nodegoat (ex: joao-nodegoat)
  3. Visibilidade: Public
  4. Pode inicializar com README (opcional), NÃO adicionar .gitignore ou licença

2.3 Habilitar GitHub Advanced Security

  1. Repository Settings → Code security and analysis
  2. Habilitar Dependency graph
  3. NÃO habilitar (vamos usar ferramentas customizadas):
    • Dependabot alerts → Usaremos Dependency Track
    • Dependabot security updates → Gerenciamento manual de dependências
    • Secret scanning push protection → Usaremos Gitleaks no pre-commit e CI/CD

3. Setup do Repositório

3.1 Clonar Repositório Pessoal

# Voltar ao diretório home
cd ~

# Clonar seu repositório pessoal (será o $STUDENT_REPO)
git clone https://github.com/<sua-org>/<seu-nome>-nodegoat

# Exemplo: git clone https://github.com/cesar-devsecops-joao/joao-nodegoat

# Ou usar a variável para especificar o diretório local:
# git clone https://github.com/<sua-org>/<seu-nome>-nodegoat $STUDENT_REPO

3.2 Copiar Código Inicial

# Do diretório do instrutor
cd $INSTRUCTOR_REPO

# Copiar arquivos para seu repo
cp -r app $STUDENT_REPO/
cp -r config $STUDENT_REPO/
cp package.json package-lock.json server.js Dockerfile docker-compose.yaml .dockerignore .gitignore .justfile $STUDENT_REPO/

# Ir para seu repo
cd $STUDENT_REPO

# Commit inicial
git add .
git commit -m "feat: initial NodeGoat setup"
git push origin main

3.3 Testar Aplicação

# Subir app e MongoDB
just start

# Acessar no browser: http://localhost:4000
# Popular banco: http://localhost:4000/tutorial/db-reset

# Parar
just stop

4. Pre-commit Hooks

4.1 Copiar Configurações

# Do repo do instrutor
cd $INSTRUCTOR_REPO

cp .pre-commit-config.yaml $STUDENT_REPO/
mkdir -p $STUDENT_REPO/scripts
cp scripts/DAST_zap.sh scripts/npm_audit_summary.sh scripts/zap.context $STUDENT_REPO/scripts/

# Ir para seu repo
cd $STUDENT_REPO

git add .
git commit -m "feat: add pre-commit hooks configuration"
git push origin main

4.2 Ativar Hooks

pre-commit install

4.3 Testar Hooks

# Teste - Secret Scanning
echo 'GITLAB_TOKEN="glpat-1234567890abcdefghij"' > .env
git add .env
git commit -m "test: secret detection"
# ❌ Deve falhar (Gitleaks detecta)

# Limpar
git reset HEAD~1 && rm .env

4.4 Desinstalar Hooks

⚠️ IMPORTANTE: Após testar, desinstale os pre-commit hooks. Usaremos security gates diferentes nos workflows de CI/CD para não atrapalhar os testes:

pre-commit uninstall

5. Kubernetes Local

5.1 Copiar Configurações K8s

# Do repo do instrutor
cd $INSTRUCTOR_REPO

cp kind-config.yaml $STUDENT_REPO/
mkdir -p $STUDENT_REPO/k8s/metrics-server
cp -r k8s/metrics-server/* $STUDENT_REPO/k8s/metrics-server/

# Ir para seu repo
cd $STUDENT_REPO

git add kind-config.yaml k8s/
git commit -m "feat: add Kubernetes configuration"
git push origin main

5.2 Deploy Cluster

# No repo do instrutor (tem justfile completo)
cd $INSTRUCTOR_REPO
just deploy-kind-cluster

5.3 Verificar Cluster

# Verificar nodes
kubectl get nodes

# Verificar metrics-server
kubectl get pods -n kube-system | grep metrics-server

# Verificar ferramentas instaladas
kubectl version --client
kind version
helm version
kubectx --version
kubens --version
k9s version

6. GitHub Actions Runner

6.1 Criar GitHub PAT

  1. GitHub → Settings → Developer settings
  2. Personal access tokens → Tokens (classic)
  3. Generate new token (classic)
  4. Scopes: repo, admin:org
  5. Copiar token gerado (será usado como GITHUB_PAT no próximo passo)

6.2 Deploy Runner

# No repo do instrutor
cd $INSTRUCTOR_REPO

# Criar arquivo com credenciais
# Substitua:
#   <sua-org> = nome da organização criada na seção 2.1
#   ghp_seu_token_aqui = token copiado na seção 6.1
cat > .env.secrets << 'EOF'
GITHUB_CONFIG_URL=https://github.com/<sua-org>
GITHUB_PAT=ghp_seu_token_aqui
EOF

# Deploy Actions Runner Controller
just setup-github-runners

6.3 Verificar Instalação

# Verificar pods
kubectl get pods -n arc-systems
kubectl get pods -n arc-runners

# Verificar runner scale set
kubectl get runnerscaleset -n arc-runners

No GitHub:

  • Organization Settings → Actions → Runners
  • Deve aparecer: arc-runner-set (Active)
  • ⚠️ IMPORTANTE - Habilitar para repositórios públicos:
    1. Na mesma página (Organization Settings → Actions → Runners)
    2. Clicar na aba "Runner groups"
    3. Clicar no grupo "Default"
    4. Marcar a opção "Allow public repositories"
    5. Clicar em "Save group" para salvar alterações

7. Workflow 00 - Debug

7.1 Copiar Workflow

# Do repo do instrutor
cd $INSTRUCTOR_REPO

mkdir -p $STUDENT_REPO/.github/workflows/
cp .github/workflows/00-debug.yaml $STUDENT_REPO/.github/workflows/

# Ir para seu repo
cd $STUDENT_REPO

git add .github/
git commit -m "ci: add debug workflow"
git push origin main

7.2 Criar PR de Teste

git checkout -b test-runner-connectivity
echo "# Testing runners" > TEST.md
git add TEST.md
git commit -m "test: verify runner connectivity"
git push origin test-runner-connectivity

7.3 Verificar Execução

No GitHub:

  1. Pull Requests → Abrir PR criado
  2. Aba "Checks"
  3. Confirmar 2 jobs em paralelo:
    • ✅ Debug - connectivity
    • ✅ Debug - docker-dind

Troubleshooting:

  • connectivity falha → Problema no ARC/runner
  • docker-dind falha → Verificar containerMode.type="dind"

Limpar:

  1. Fechar PR (não merge)
  2. Deletar branch: git branch -D test-runner-connectivity

8. Workflow 01 - Secret Scanning

8.1 Obter Licença Gitleaks

  1. Acessar https://gitleaks.io/ e criar conta
  2. Dashboard → Licenses
  3. Solicitar GitHub organization license
  4. Copiar licença (string eyJ...)

8.2 Configurar Secret no GitHub

  1. Repository Settings → Secrets and variables → Actions
  2. New repository secret
  3. Name: GITLEAKS_LICENSE
  4. Value: colar licença
  5. Add secret

8.3 Copiar Workflow

# Do repo do instrutor
cd $INSTRUCTOR_REPO

# Remover workflow anterior
rm $STUDENT_REPO/.github/workflows/00-debug.yaml

# Copiar workflow de secret scanning
cp .github/workflows/01-secret-scanning.yaml $STUDENT_REPO/.github/workflows/

# Ir para seu repo
cd $STUDENT_REPO

git add .github/workflows/
git commit -m "ci: remove debug workflow and add secret scanning"
git push origin main

8.4 Testar Secret Scanning

# Criar branch de teste
git checkout -b test-secret-scanning

# Opção 1: Copiar chave privada (simular leak)
cp artifacts/cert/server.key leaked-private-key.pem

# Opção 2: Adicionar secrets de teste
cat > test-secrets.env << 'EOF'
AWS_ACCESS_KEY_ID="AKIAIOSFODNN7EXAMPLE"
GITHUB_TOKEN="ghp_1234567890abcdefghijklmnopqrstuvwxyz"
DATABASE_PASSWORD="super-secret-password-123"
EOF

git add leaked-private-key.pem test-secrets.env
git commit -m "test: add secrets for scanning demo"
git push origin test-secret-scanning

Verificar resultados:

  • Abrir PR no GitHub
  • Aba "Checks": Verificar Trivy e Gitleaks
    • Trivy: Categoriza por severidade (CRITICAL, HIGH, MEDIUM, LOW)
    • Gitleaks: Reporta como WARNING
  • Aba "Security" → "Code scanning": Ver anotações inline com tipo de secret detectado

Limpar:

  • Fechar PR sem merge
  • Deletar branch: git branch -D test-secret-scanning

9. Workflow 02 - SCA (Software Composition Analysis)

9.1 Deploy Dependency Track

# No repo do instrutor
cd $INSTRUCTOR_REPO

just start-dependency-track

9.2 Configurar API Key

No Dependency Track:

  1. Administration → Access Management → Teams
  2. Selecionar team "Automation"
  3. Aba "API Keys" → "+ Create API Key"
  4. Copiar API Key

No GitHub:

  1. Repository Settings → Secrets and variables → Actions
  2. New repository secret
  3. Name: DEPENDENCYTRACK_APIKEY
  4. Value: colar API Key
  5. Add secret

9.3 Copiar Workflow

# Do repo do instrutor
cd $INSTRUCTOR_REPO

# Remover workflow anterior
rm $STUDENT_REPO/.github/workflows/01-secret-scanning.yaml

# Copiar workflow de SCA
cp .github/workflows/02-sca.yaml $STUDENT_REPO/.github/workflows/

# Ir para seu repo
cd $STUDENT_REPO

git add .github/workflows/
git commit -m "ci: remove secret scanning workflow and add SCA"
git push origin main

9.4 Testar SCA

# Criar branch de teste
git checkout -b test-sca

# Adicionar dependência vulnerável ao package.json
# Encontrar a linha "dependencies": { e adicionar:
# "axios": "0.21.1",

# Ou usar sed (Linux/macOS):
sed -i.bak '/"dependencies": {/a\
    "axios": "0.21.1",' package.json

# Gerar package-lock.json
npm install

git add package.json package-lock.json
git commit -m "test: add vulnerable dependency for SCA demo"
git push origin test-sca

Criar PR e verificar:

No Dependency Track (http://localhost:8081):

  • Projeto "app" criado automaticamente
  • Overview: Métricas resumidas, risk score
  • Components: Dependências diretas e transitivas
  • Audit Vulnerabilities: CVEs encontrados
    • Ver CVSS score (severidade técnica)
    • Ver EPSS score (probabilidade de exploração)

No GitHub:

  • Aba "Security" → "Code scanning": Alertas do Trivy
  • Aba "Insights" → "Dependency graph": Árvore de dependências

Limpar:

  • Fechar PR e deletar branch
  • Reverter package.json se necessário

10. Workflow 03 - SAST (Static Analysis)

10.1 Deploy SonarQube

# Do repo do instrutor
cd $INSTRUCTOR_REPO

# Parar Dependency Track
just stop-dependency-track

# Copiar configuração SonarQube
mkdir -p $STUDENT_REPO/k8s/sonarqube
cp k8s/sonarqube/sonarqube-values.yaml $STUDENT_REPO/k8s/sonarqube/

cd $STUDENT_REPO
git add k8s/sonarqube/
git commit -m "feat: add SonarQube Helm values configuration"
git push origin main

# Deploy SonarQube
cd $INSTRUCTOR_REPO
just start-sonarqube

10.2 Gerar Tokens no SonarQube

Token 1 - Global Analysis Token:

  1. My Account → Security
  2. Generate Tokens → Token name: github-actions-token
  3. Type: Global Analysis Token
  4. Expires in: No expiration
  5. Generate → Copiar token

Token 2 - User Token:

  1. Mesma página (My Account → Security)
  2. Token name: github-actions-user-token
  3. Type: User Token
  4. Expires in: No expiration
  5. Generate → Copiar token

Configurar no GitHub:

  1. Repository Settings → Secrets and variables → Actions
  2. Criar dois secrets:
    • Name: SONAR_TOKEN | Value: Global Analysis Token
    • Name: SONAR_USER_TOKEN | Value: User Token

10.3 Copiar Workflow

# Do repo do instrutor
cd $INSTRUCTOR_REPO

# Remover workflow anterior
rm $STUDENT_REPO/.github/workflows/02-sca.yaml

# Copiar workflow de SAST
cp .github/workflows/03-sast.yaml $STUDENT_REPO/.github/workflows/

# Ir para seu repo
cd $STUDENT_REPO

git add .github/workflows/
git commit -m "ci: remove SCA workflow and add SAST"
git push origin main

10.4 Testar SAST

# Criar branch de teste
git checkout -b test-sast

# Copiar arquivo com vulnerabilidades intencionais
cp app/data/allocations-dao.js app/data/teste.js

git add app/data/teste.js
git commit -m "test: add vulnerable code for SAST demonstration"
git push origin test-sast

Criar PR e verificar:

No GitHub:

  • Abrir PR da branch test-sast
  • Aba "Security" → "Code scanning"
  • Filtrar por Tool: "SonarQube"
  • Ver anotações inline no código

No SonarQube (http://localhost:9000):

  • Projeto "app" criado
  • Métricas: Security, Reliability, Maintainability
  • Security Hotspots
  • Issues: NoSQL Injection, Code Smells, Complexidade

Limpar:

  • Fechar PR e deletar branch

11. Workflow 04 - Container Scanning

11.1 Criar Conta Docker Hub

  1. Acessar https://hub.docker.com/signup
  2. Criar conta gratuita
  3. Verificar email
  4. Login: https://hub.docker.com

11.2 Criar Access Token

  1. Avatar → Account Settings → Security
  2. New Access Token
  3. Description: "GitHub Actions - NodeGoat DevSecOps"
  4. Access permissions: Read, Write, Delete
  5. Generate → Copiar token

11.3 Criar Repositório Docker Hub

  1. Repositories → Create Repository
  2. Name: nodegoat
  3. Visibility: Public
  4. Create

11.4 Configurar Secrets GitHub

Secret:

  1. Repository Settings → Secrets and variables → Actions
  2. New repository secret
  3. Name: DOCKERHUB_TOKEN
  4. Value: colar Access Token
  5. Add secret

Variable:

  1. Aba "Variables" → New repository variable
  2. Name: DOCKERHUB_USERNAME
  3. Value: seu username Docker Hub
  4. Add variable

11.5 Deploy ArcherySec

# Do repo do instrutor
cd $INSTRUCTOR_REPO

# Copiar manifestos ArcherySec
mkdir -p $STUDENT_REPO/k8s/archery
cp -r k8s/archery/* $STUDENT_REPO/k8s/archery/

cd $STUDENT_REPO
git add k8s/archery/
git commit -m "feat: add ArcherySec Kubernetes manifests"
git push origin main

# Parar SonarQube e subir ArcherySec
cd $INSTRUCTOR_REPO
just stop-sonarqube
just start-archerysec

# Aguardar pods Ready
kubectl get pods -n archerysec -w

11.6 Copiar Workflow

# Do repo do instrutor
cd $INSTRUCTOR_REPO

# Remover workflow anterior
rm $STUDENT_REPO/.github/workflows/03-sast.yaml

# Copiar workflow de container scanning
cp .github/workflows/04-container-scanning.yaml $STUDENT_REPO/.github/workflows/

# Ir para seu repo
cd $STUDENT_REPO

git add .github/workflows/
git commit -m "ci: remove SAST workflow and add container scanning"
git push origin main

11.7 Testar Container Scanning

# Criar PR de teste
git checkout -b test-container-scanning
echo "test" >> README.md
git add README.md
git commit -m "test: trigger container scanning"
git push origin test-container-scanning

Verificar:

  • GitHub Actions: Build multi-plataforma
  • Docker Hub: Imagem publicada
  • Code Scanning: Vulnerabilidades e licenças

Limpar:

  • Fechar PR e deletar branch

12. Workflow 05 - IaC Scanning

12.1 Configurar ArcherySec API Key

No ArcherySec (http://localhost:8083):

  1. Login: admin@intra.local / admin
  2. Settings → Access Keys
  3. Generate New Key → Copiar token

No GitHub:

  1. Repository Settings → Secrets and variables → Actions
  2. New repository secret
  3. Name: ARCHERYSEC_APIKEY
  4. Value: colar token
  5. Add secret

12.2 Copiar Workflow

# Do repo do instrutor
cd $INSTRUCTOR_REPO

# Remover workflow anterior
rm $STUDENT_REPO/.github/workflows/04-container-scanning.yaml

# Copiar workflow de IaC scanning
cp .github/workflows/05-iac-scanning.yaml $STUDENT_REPO/.github/workflows/

# Ir para seu repo
cd $STUDENT_REPO

git add .github/workflows/
git commit -m "ci: remove container scanning and add IaC scanning"
git push origin main

12.3 Testar IaC Scanning

# Criar PR de teste
git checkout -b test-iac-scanning
echo "test" >> README.md
git add README.md
git commit -m "test: trigger IaC scanning"
git push origin test-iac-scanning

Verificar:

  • GitHub Actions: Trivy e Checkov scanning
  • ArcherySec: Resultados centralizados

Limpar:

  • Fechar PR e deletar branch

13. Workflow 06 - Build e Deploy

13.1 Deploy NodeGoat no Kubernetes

# Do repo do instrutor
cd $INSTRUCTOR_REPO

# Copiar manifestos NodeGoat
mkdir -p $STUDENT_REPO/k8s/nodegoat
cp -r k8s/nodegoat/* $STUDENT_REPO/k8s/nodegoat/

cd $STUDENT_REPO
git add k8s/nodegoat/
git commit -m "feat: add NodeGoat Kubernetes manifests"
git push origin main

# Parar ArcherySec e subir NodeGoat
cd $INSTRUCTOR_REPO
just stop-archerysec
just start-nodegoat-k8s

# Aguardar pods Ready
kubectl get pods -n nodegoat -w

13.2 Configurar KUBECONFIG Secret

# macOS - Copiar para clipboard
kind get kubeconfig --name devsecops | \
  sed 's|https://127.0.0.1:[0-9]*|https://kubernetes.default.svc|g' | \
  base64 | pbcopy

# Linux - Copiar para clipboard
kind get kubeconfig --name devsecops | \
  sed 's|https://127.0.0.1:[0-9]*|https://kubernetes.default.svc|g' | \
  base64 -w 0 | xclip -selection clipboard

No GitHub:

  1. Repository Settings → Secrets and variables → Actions
  2. New repository secret
  3. Name: KUBECONFIG
  4. Value: colar output base64
  5. Add secret

13.3 Copiar Workflow

# Do repo do instrutor
cd $INSTRUCTOR_REPO

# Remover workflow anterior
rm $STUDENT_REPO/.github/workflows/05-iac-scanning.yaml

# Copiar workflow de build/deploy
cp .github/workflows/06-build-deploy.yaml $STUDENT_REPO/.github/workflows/

# Ir para seu repo
cd $STUDENT_REPO

git add .github/workflows/
git commit -m "ci: remove IaC scanning and add build/deploy"
git push origin main

13.4 Testar Build e Deploy

# Criar PR de teste
git checkout -b test-build-deploy
echo "test" >> README.md
git add README.md
git commit -m "test: trigger build and deploy"
git push origin test-build-deploy

Verificar:

  • GitHub Actions: Build → Deploy staging
  • Docker Hub: Imagem com tag da branch
  • Kubernetes: kubectl get pods -n nodegoat
  • App: http://localhost:8084

Fazer merge:

  • Aprovar e merge PR para main
  • Verificar build com tag latest

14. Referência Rápida

Just:

just --list              # Comandos
just setup               # Instalar ferramentas
just start               # Subir app
just stop                # Parar app
just deploy-kind-cluster # Criar K8s

Kubernetes:

kubectl get nodes                         # Nodes
kubectl get pods -n <namespace>           # Pods
kubectl logs -n <namespace> <pod>         # Logs
kubectl get runnerscaleset -n arc-runners # Runners
kubectx                                   # Clusters
kubens                                    # Namespaces
k9s                                       # TUI

Git:

git status               # Status
git add .                # Add
git commit -m "msg"      # Commit
git push origin <branch> # Push
git checkout -b <branch> # Nova branch

Docker:

docker ps                # Containers
docker compose logs -f   # Logs
docker compose up -d     # Subir
docker compose down      # Parar

Navegação:

cd $INSTRUCTOR_REPO                # Repo instrutor
cd $STUDENT_REPO     # Seu repo
pwd                          # Diretório atual

Apêndice A: Configuração do WSL 2

A.1 Pré-requisitos

  • Windows 10: Versão 2004+ (Build 19041+)
  • Windows 11: Qualquer versão
  • Permissões de Administrador

Verificar versão:

  1. Win + R
  2. Digite winver
  3. Verificar requisitos

A.2 Instalar WSL 2

PowerShell como Admin:

wsl --install

Isso instala:

  • Windows Subsystem for Linux
  • Virtual Machine Platform
  • Kernel Linux
  • Ubuntu (padrão)

⚠️ Reiniciar Windows:

Restart-Computer

A.3 Configurar Ubuntu

  1. Abrir "Ubuntu" no menu Iniciar
  2. Aguardar inicialização (demora na 1ª vez)
  3. Criar usuário e senha

A.4 Verificar Instalação

wsl -l -v

Deve mostrar:

NAME      STATE      VERSION
* Ubuntu  Running    2

Se VERSION = 1:

wsl --set-version Ubuntu 2
wsl --set-default-version 2

A.5 Atualizar Ubuntu

sudo apt update && sudo apt upgrade -y

A.6 Comandos Úteis

wsl                    # Iniciar Ubuntu
wsl -l -v              # Listar distribuições
wsl --shutdown         # Desligar WSL
wsl --terminate Ubuntu # Desligar Ubuntu

A.7 Acessar Arquivos

Windows → Ubuntu:

  • Explorador: \\wsl$\Ubuntu\home\seuusuario

Ubuntu → Windows:

cd /mnt/c/Users/SeuUsuario  # Drive C:

A.8 Troubleshooting

Erro "requires update":

Erro "Virtualization not enabled":

  • BIOS → Habilitar VT-x/AMD-V

Instalação trava:

wsl --shutdown

Após configurar WSL 2: Voltar para Seção 1

About

No description, website, or topics provided.

Resources

Readme
Activity
Custom properties

Stars

0 stars

Watchers

0 watching

Forks

0 forks
Report repository

Releases

No releases published

Packages

No packages published

Contributors 3

  •  
  •  
  •  

Languages