Projeto: Criação de uma Infraestrutura para Ambientes de Stage e Produção na AWS, usando EKS.

Pré-requisitos para criar o ambiente

• Conta na AWS
• Credenciais do IAM
• AWS CLI
• Helm
• Trivy
• Sonarqube
• Git
• Docker
• Docker Scout
• Kubectl
• Terraform

Step-1: Criando ambiente de stage

• Clone o repositório para versionar o código do projeto:

git clone https://github.com/thdevopssre/infra-test-eks.git

• Acesse o diretório onde estão os arquivos do Terraform para criar o cluster EKS de stage.

cd /EKS/stg

• Agora no diretorio do arquivos do Terraform vamos usar os comando para cria o cluster.

terraform init

terraform fmt

terraform validate

terraform plan

terraform apply -auto-approve

• OBS: Use o comando terraform apply -auto-approve apenas se você tiver certeza de que todos os recursos mostrados no terraform plan são os necessários para sua infraestrutura. Caso contrário, use apenas o comando terraform apply sem -auto-auto-approve. Ele mostrará todo o plano da sua infraestrutura e solicitará confirmação para executar o comando. yes ou no

Use um comando da AWS para interagir com o cluster via CLI usando o kubectl e também criar e atualizar o arquivo kubeconfig:

-"Utilizaremos um comando da AWS para interagir com o cluster por meio da CLI, utilizando o kubectl, e também para criar e atualizar o arquivo kubeconfig."

Lembre-se de substituir NOME_DO_CLUSTER e SUA_REGIAO_AWS pelos valores específicos do seu ambiente AWS EKS. Certifique-se de revisar a documentação para obter informações mais detalhadas e ajustar conforme necessário para atender aos requisitos específicos do seu ambiente.

aws eks update-kubeconfig --region region-code --name my-cluster

**Step-1: Segurança

1.nstale SonarQube e Trivy:

• Instale SonarQube e Trivy na instância EC2 para verificar vulnerabilidades.

  docker run -d --name sonar -p 9000:9000 sonarqube:lts-community

Acessar:

publicIP:9000 (por padrão, nome de usuário e senha são admin)

Para instalar o Trivy:

sudo apt-get install wget apt-transport-https gnupg lsb-release
wget -qO - https://aquasecurity.github.io/trivy-repo/deb/public.key | sudo apt-key add -
echo deb https://aquasecurity.github.io/trivy-repo/deb $(lsb_release -sc) main | sudo tee -a /etc/apt/sources.list.d/trivy.list
sudo apt-get update
sudo apt-get install trivy        

para fazer o escaner da imagem usando trivy:

trivy image <imageid>

2.Para instalar o docker scout Script

vim docker.sh

./docker.sh

# Add Docker's official GPG key:
sudo apt-get update
sudo apt-get install ca-certificates curl gnupg
sudo install -m 0755 -d /etc/apt/keyrings
curl -fsSL https://download.docker.com/linux/ubuntu/gpg | sudo gpg --dearmor -o /etc/apt/keyrings/docker.gpg
sudo chmod a+r /etc/apt/keyrings/docker.gpg
# Add the repository to Apt sources:
echo \
  "deb [arch=$(dpkg --print-architecture) signed-by=/etc/apt/keyrings/docker.gpg] https://download.docker.com/linux/ubuntu \
  $(. /etc/os-release && echo "$VERSION_CODENAME") stable" | \
  sudo tee /etc/apt/sources.list.d/docker.list > /dev/null
sudo apt-get update
sudo apt-get install docker-ce docker-ce-cli containerd.io docker-buildx-plugin docker-compose-plugin
curl -sSfL https://raw.githubusercontent.com/docker/scout-cli/main/install.sh | sh -s -- -b /usr/local/bin
sudo usermod -aG docker ubuntu
newgrp docker
sudo chmod 777 /var/run/docker.sock

3.Integre SonarQube e configure:

Integre o SonarQube a sua pipeline de CI/CD. Configure o SonarQube para analisar o código em busca de problemas de qualidade e segurança.

Step-2: Configurando O Ingress-Nginx Controller e o cert-manager

Como vamos expor a nossa aplicação para fora do cluste usaremos um dominio e um servidro web chamado Nginx ele ira garantir que a nossa aplicaç~ao funcione dentro do cluster de maneira segura e eficiente. O Ingress-Nginx Controller atua como um componente crucial para gerenciar o roteamento de tráfego externo para os serviços internos do cluster Kubernetes.

Além disso, para garantir uma comunicação segura e estabelecer uma conexão HTTPS confiável, utilizaremos o Cert-Manager. O Cert-Manager é uma ferramenta especializada em automatizar a emissão e renovação de certificados TLS, essenciais para garantir a segurança da transmissão de dados entre o servidor web Nginx e os usuários finais.

Ao implementar essas soluções em conjunto, o Ingress-Nginx Controllere o Cert-Manager proporcionam uma infraestrutura robusta para a exposição segura da nossa aplicação. O Ingress-Nginx direciona o tráfego externo para os serviços internos, enquanto o Cert-Manager automatiza a gestão dos certificados TLS, garantindo a integridade e segurança das comunicações.

• Instalando um Ingress Controller Vamos continuar usando o Nginx Ingress Controller como exemplo, que é amplamente adotado e bem documentado.

kubectl apply -f https://raw.githubusercontent.com/kubernetes/ingress-nginx/controller-v1.8.2/deploy/static/provider/aws/deploy.yaml

Instalar o Ingress-Nginx Controller com Helm**

É recomendado que no ambiente de produção o Ingress-Nginx Controller seja instalado com Helm se estiver usando algum provedor de Nuvem.

Utilize o seguinte comando Helm para instalar o Ingress-Nginx Controller no namespace ingress-nginx:

helm upgrade --install ingress-nginx ingress-nginx \
  --repo https://kubernetes.github.io/ingress-nginx \
  --namespace ingress-nginx --create-namespace

Este comando instalará o controlador Ingress-Nginx no namespace ingress-nginx e criará o namespace se ele ainda não existir. Este comando é idempotente, o que significa que ele instalará o controlador se ainda não estiver instalado ou o atualizará se já estiver instalado.

Verificar a instalação:

kubectl wait --namespace ingress-nginx \
  --for=condition=ready pod \
  --selector=app.kubernetes.io/component=controller \
  --timeout=120s

Isso garante que o controlador esteja pronto e em execução antes de prosseguir.

1. Configurar o Firewall:

Certifique-se de configurar o firewall para permitir o tráfego nas portas necessárias. O controlador Ingress-Nginx geralmente requer as portas 80 e 443 abertas.

Para ver quais portas estão sendo usadas, execute:

kubectl -n ingress-nginx get pod -o yaml

Em geral, é necessário abrir a Porta 8443 entre todos os hosts nos quais os nós do Kubernetes estão em execução, usada para o controlador de admissão Ingress-Nginx.

1. Testar os templates Helm localmente usando o Kind:

Crie um aqruivo com om nome kind-config.yaml:

kind: Cluster
apiVersion: kind.x-k8s.io/v1alpha4
nodes:
- role: control-plane
  kubeadmConfigPatches:
  - |
    kind: InitConfiguration
    nodeRegistration:
      kubeletExtraArgs:
        node-labels: "ingress-ready=true"
  extraPortMappings:
  - containerPort: 80
    hostPort: 80
    protocol: TCP
  - containerPort: 443

Use o comando kubectl para criar o cluster com 1 node:

kind create cluster --name kind-multinodes --config kind-config.yaml  

Agora instale o ingress-nginix-controller:

helm repo add ingress-nginx https://kubernetes.github.io/ingress-nginx
helm repo update

kubectl create namespace nginx  

 helm install nginx ingress-nginx/ingress-nginx --namespace nginx

kubectl port-forward --namespace=ingress-nginx service/ingress-nginx-controller 8080:80

Agora, você pode acessar a sua aplicação localmente usando http://localhost:8080.

Agora, vamos criar um certificado para nossa aplicação usando o arquivo de configuração fornecido pelo Cert-Manager crie um arquivo com o nome cert-manager.ymal e siga os comandos abixo:

apiVersion: cert-manager.io/v1
kind: ClusterIssuer
metadata:
  name: letsencrypt-staging
spec:
  acme:
    server: https://acme-staging-v02.api.letsencrypt.org/directory
    email: 
    privateKeySecretRef:
      name: letsencrypt-staging
    solvers:
    - http01:
        ingress:
          class: nginx

1. Certifique-se de que os CRDs necessários estão instalados. Você pode fazer isso aplicando os arquivos CRD fornecidos pelo Cert Manager. Por exemplo:

kubectl apply -f https://github.com/jetstack/cert-manager/releases/download/v1.6.0/cert-manager.crds.yaml

• Certifique-se de que o arquivo cert-manager-stg.yaml refere-se a um
• ClusterIssuer válido na versão correta. Verifique se a definição do
• ClusterIssuer está correta no arquivo cert-manager-stg.yaml.

2. Execute o comando para aplicar as configurações ao seu cluster Kubernetes:

kubectl apply -f cert-manager-stg.yaml

3. Verifique se o certificado foi criado:

kubectl get clusterissuers letsencrypt-staging

OBS:: Nos ambientes de Produção, não declaramos "staging" dentro do endereço do servidor https. Os arquivos de configuração do cert-manager e o comando para instalar o Nginx Ingress Controller podem ser declarados na pipeline.O cert-manager pode ser usado junto aos aqruivos de configuração do Helm.

Instalação PostgreSQL com Helm no cluster Kind

• Navegue para o diretorio onde esta a pasta contendo os arquivos helm e execute os seguintes comandos:

1.Instalar um release:

helm install go-stg ./descoshop

2.Listar as releases:

helm list

3.Verificar o Status do release:

 helm status <nome da release>

4.Verificar o pod associado a release:

kubectl get pods

kubectl exec -it <nome-do-pod> -- env

Para testar a conexão com o banco de dados PostgreSQL, acessar o shell e criar uma tabela usando kubectl exec, você pode seguir os seguintes passos:

1. Obter o nome do pod PostgreSQL

kubectl get pods

Anote o nome do pod que corresponde ao PostgreSQL, por exemplo, kube-news-postgre-6876f6bf75-9nxm9

2.cessar o shell do PostgreSQL

Use o comando kubectl exec para acessar o shell do PostgreSQL:

kubectl exec -it postgre-6876f6bf75-9nxm9 -- psql -U descoshop -d descoshop-stg

Passo 1: Obter o nome do pod PostgreSQL

Use o seguinte comando para listar os pods em execução no seu cluster e encontre o nome do pod PostgreSQL:

kubectl get pods

Anote o nome do pod que corresponde ao PostgreSQL, por exemplo, postgre-6876f6bf75-9nxm9.

Passo 2: Acessar o shell do PostgreSQL

Use o comando kubectl exec para acessar o shell do PostgreSQL:

kubectl exec -it postgre-6876f6bf75-9nxm9 -- psql -U postgres-prod -d descoshop

Isso abrirá o shell interativo do PostgreSQL para o banco de dados descoshop-stg usando o usuário descoshop.

1. Criar a tabela Dentro do shell do PostgreSQL, execute os comandos SQL para criar a tabela:

CREATE TABLE config (
    id SERIAL PRIMARY KEY,
    key VARCHAR(50) NOT NULL,
    value VARCHAR(255) NOT NULL
);

INSERT INTO config (key, value) VALUES
    ('POSTGRES_DB', 'descoshop-prod'),
    ('POSTGRES_USER', 'descoshop'),
    ('POSTGRES_PASSWORD', 'tonystark@123'),
    ('GOOGLE_RECAPTCHA_URL', 'https://google.com/recaptcha/api'),
    ('ENABLE_RECAPTCHA', 'true'),
    ('BUCKET_NFE', 'https://s3.console.aws.amazon.com/s3/home?region=us-east-1#');

Isso criará a tabela config e inserirá os dados fornecidos.

1. Verificar a tabela

SELECT * FROM config;

Step-5:Criando o CI com O Github Actions

Com o nosso cluster provisionado, agora podemos focar na criação da Pipeline. Usaremos o Github Actions como ferramenta de CI para realizar a integração com o cluster e com a nossa aplicação.

• configure as secrets e variables do cloud provider e do registry da imagem Docker no Actions do Github.
• Settings => actions => Secrets and variables => Actions => New repository secret

Com o nosso cluster provisionado, agora podemos focar na criação da Pipeline. Usaremos o Github Actions como ferramenta de CI para realizar a integração com o cluster e com a nossa aplicação.

Configure as credenciais do Docker e do EKS para permitir que o Github Actions interaja com a pipeline.

name: Build and push Docker image to Docker registry

name: Build, Analyze, and Scan

on:
 push:
   branches:
     - main

jobs:
 build-analyze-scan:
   name: Build, Analyze, and Scan
   runs-on: [self-hosted]
   steps:
     - name: Checkout code
       uses: actions/checkout@v2
       with:
         fetch-depth: 0

     - name: Build and analyze with SonarQube
       uses: sonarsource/sonarqube-scan-action@master
       env:
         SONAR_TOKEN: ${{ secrets.SONAR_TOKEN }}
         SONAR_HOST_URL: ${{ secrets.SONAR_HOST_URL }}

     - name: Docker Login
       run: docker login -u ${{ secrets.DOCKERHUB_USERNAME }} -p ${{ secrets.DOCKERHUB_TOKEN }}
       
     - name: Trivy file scan
       run: trivy fs . > trivyfs.txt
       
     - name: Docker Scout Scan
       run: |
         docker-scout quickview fs://.
         docker-scout cves fs://.

     - name: Docker build and push
       run: |
         # Run commands to build and push Docker images
         docker build -t webtest:latest .
         docker tag webtest thsre/webtest:latest
         docker push thsre/webtest:latest
       env:
         DOCKER_CLI_ACI: 1

     - name: Image scan
       run: trivy image thsre/webtest:latest > trivyimage.txt

     - name: Docker Scout Image Scan
       run: |
         docker-scout quickview thsre/webtest:latest
         docker-scout cves thsre/webtest:latest

 deploy:
   needs: build-analyze-scan
   runs-on: [self-hosted]
   steps:
     - name: Docker Pull Image
       run: docker pull thsre/webtest:latest

     - name: Deploy to Container
       run: docker run -d --name game -p 8080:8080 thsre/webtest:latest

     - name: Update kubeconfig
       run: aws eks update-kubeconfig --name matrix-prod --region us-east-1

     - name: Deploy nodejs Helm chart to EKS
       run: |
         helm install descoshop ./go-prod
         helm install postgresql ./postgres-prod

Step-6: Deploy da Aplicação com ArgoCD

Instale o ArgoCD:

Todos esses componentes podem ser instalados usando um manifesto fornecido pelo Projeto Argo:

kubectl create namespace argocd
kubectl apply -n argocd -f https://raw.githubusercontent.com/argoproj/argo-cd/v2.4.7/manifests/install.yaml

kubectl patch svc argocd-server -n argocd -p '{"spec": {"type": "LoadBalancer"}}'

export ARGOCD_SERVER=`kubectl get svc argocd-server -n argocd -o json | jq --raw-output '.status.loadBalancer.ingress[0].hostname'`

export ARGO_PWD=`kubectl -n argocd get secret argocd-initial-admin-secret -o jsonpath="{.data.password}" | base64 -d`

echo $ARGOCD_SERVER

echo $ARGO_PWD

• Defina seu repositório GitHub como fonte no Argocd:

Depois de instalar o ArgoCD, você precisa configurar seu repositório GitHub como fonte para a implantação do seu aplicativo. Isso normalmente envolve configurar a conexão com o seu repositório e definir a fonte do seu aplicativo ArgoCD. As etapas específicas dependerão de sua configuração e requisitos.

• Crie um aplicativo ArgoCD:

• name:Defina o nome do seu aplicativo.

• destination: Defina o destino onde seu aplicativo deve ser implantado.

• project: Especifique o projeto ao qual o aplicativo pertence.

• source: defina a origem do seu aplicativo, incluindo a URL do repositório GitHub, a revisão e o caminho para o aplicativo dentro do repositório.

• syncPolicy: Configure a política de sincronização, incluindo sincronização automática, remoção e autocorreção.

Step-7: Monitoramento

`app` 

postgresql

Sonarqube

PS: Se tudo ocorrer perfeitamente bem no ambiente de stage, agora podemos repetir o mesmo processo para construir o ambiente de produção.

Step-4: Removendo o ambiente de stage ou proução No diretorio do arquivos de configuração do Terraform aplique o comando:

terraform destroy

Este comando irá remover todos os recursos que foram provisionados na AWS, garantindo que você não seja cobrado por nada.

Resumo do Projeto

Descrição

Este projeto visa configurar a infraestrutura para a aplicação "descoshop", que será implantada em dois ambientes: teste e produção, utilizando clusters Kubernetes. A entrega do projeto envolve a criação de arquivos de configuração, configuração de fluxo de integração contínua e implementação de recursos AWS.

Ambiente

• Ambiente de Testes: descoshop.stg.descomplica.com.br
• Database: descoshop-stg.rds.aws.amazon.com
• Pods: 1 a 4, CPU/Memory: request 200m/192Mi, limit 400m/512Mi
• Variáveis de Ambiente: GOOGLE_RECAPTCHA_URL, ENABLE_RECAPTCHA, BUCKET_NFE
• Ambiente de Produção: descoshop.descomplica.com.br
• Database: descoshop-prd.rds.aws.amazon.com
• Pods: 4 a 10, CPU/Memory: request 200m/192Mi, limit 400m/512Mi
• Variáveis de Ambiente: GOOGLE_RECAPTCHA_URL, ENABLE_RECAPTCHA, BUCKET_NFE

Segurança:

As informações de conexão ao banco de dados devem ser protegidas usando recursos seguros do Kubernetes. Um bucket S3 privado será criado para armazenar notas fiscais eletrônicas, com regras de acesso definidas.

Entregáveis:

• Arquivos Terraform para configurar o EKS,VPC, bucket S3.
• Configurações da pipeline CI/CD Github Actions.
• Arquivos de configuração da aplicação no Kubernetes (Helm templates, values, deployment, service. ingress ).
• Documentação detalhada dos passos executados.

Tecnologias Utilizadas:

Kubernetes, Docker, Terraform, Helm, Redis, Trivy, Sonarqube, Docker Scout, Git && GitHub Actions CI, CD Argocd, e recursos AWS.

Links úteis para a documentação das tecnologias utilizadas no projeto:

• Docker Builder Reference
• Docker Scout
• Docker Postgres Sample
• Docker Postgres Image
• Acqua Security Tryvi
• Redis
• Sonarqube
• Terraform AWS Provider Workspace Resource
• Terraform AWS Getting Started
• Terraform AWS Resource Tagging Guide
• Helm Docs
• Terraform AWS VPC Module
• Terraform AWS EKS Module
• Terraform AWS S3 Bucket Module
• Terraform Configuration Language Guide
• Terraform Language Values and Variables
• Go Development Use Cases
• Kubernetes Nginx Ingress Configuration
• Artifact Hub
• EKS Workshop Install Argocd
• ArgoCD Documentation
• Workflow syntax for GitHub Actions
• Cert-Manager
• PostgreSQL Commands and Language
• Terragen s3-lifecycle
• Amazon S3 Lifecycle configuration rule
• Amazon S3 modules
• AWS update kubeconfig

Para saber mais sobre Kubernetes, containers e instalações de componentes em outros sistemas operacionais, consulte o Livro Gratuito Descomplicando o Kubernetes.

Descomplicando o Kubernetes - Livro Gratuito

Descomplicando o Docker - Livro Gratuito

Postmortem SLA, SLO, SLI e Erro Budget

Link para meus artigos sobre SRE e DevOps Medium