14. DevOps e Infraestrutura

Alerta importante para desenvolvedores: Esta seção fornece uma visão geral de nossa infraestrutura e práticas DevOps. Como desenvolvedor, seu foco principal deve ser no desenvolvimento dentro do ambiente Docker local. Você não precisa se preocupar diretamente com Terraform, Kubernetes ou outros aspectos de infraestrutura gerenciados pela equipe de DevOps. No entanto, é importante ter uma compreensão básica de nossa stack para um desenvolvimento mais eficiente e alinhado com nossas práticas de infraestrutura.

Nossa empresa utiliza uma stack multi-cloud com Kubernetes e AWS auto-scaling, gerenciada através do k9s. Nossa segurança de rede é garantida pelo NOC (Network Operations Center) e Sucuri. Terraform é usado para gerenciamento de infraestrutura como código.

14.1. Infraestrutura como código

Embora a equipe de infraestrutura seja responsável pela manutenção e evolução da infraestrutura como código, é importante que os desenvolvedores entendam os princípios básicos.

Visão geral do Terraform:

# Exemplo simplificado de um arquivo Terraform
provider "aws" {
  region = "us-west-2"
}
 
resource "aws_instance" "example" {
  ami           = "ami-0c55b159cbfafe1f0"
  instance_type = "t2.micro"
 
  tags = {
    Name = "exemplo-instancia"
  }
}

Este exemplo demonstra como recursos AWS são definidos usando Terraform. A equipe de infraestrutura utiliza scripts mais complexos para gerenciar nossa infraestrutura completa.

14.2. Containerização (Docker)

Docker é essencial para nosso processo de desenvolvimento. Todos os desenvolvedores devem usar Docker para criar ambientes de desenvolvimento consistentes e isolados.

Configuração do ambiente de desenvolvimento:

1. Instale o Docker e o Docker Compose em sua máquina local.

2. Clone o repositório do projeto e navegue até o diretório.

3. Use o Docker Compose para iniciar o ambiente de desenvolvimento:

   docker-compose up -d

Exemplo de Dockerfile para uma aplicação Node.js:

FROM node:14

WORKDIR /usr/src/app

COPY package*.json ./

RUN npm install

COPY . .

EXPOSE 3000

CMD ["npm", "start"]

Exemplo de docker-compose.yml:

version: '3'
services:
  app:
    build: .
    ports:
      - "3000:3000"
    volumes:
      - .:/usr/src/app
      - /usr/src/app/node_modules
    environment:
      - NODE_ENV=development
  db:
    image: postgres:13
    environment:
      - POSTGRES_DB=myapp
      - POSTGRES_USER=user
      - POSTGRES_PASSWORD=password

14.3. Orquestração de containers (Kubernetes)

Embora os desenvolvedores não interajam diretamente com o Kubernetes, é útil entender os conceitos básicos.

Kubernetes gerencia a implantação, escalonamento e operações de containers em nossa infraestrutura de produção. Nossa equipe de DevOps utiliza k9s para gerenciamento e monitoramento do cluster Kubernetes.

14.4. Ambientes de desenvolvimento, teste e produção

Mantemos três ambientes principais:

1. Desenvolvimento (Local): Seu ambiente Docker local.
2. Teste/Staging: Um ambiente que espelha a produção, usado para testes finais.
3. Produção: O ambiente live, gerenciado pela equipe de infraestrutura.

Gerenciamento de variáveis de ambiente:

Para alterar variáveis de ambiente em seu ambiente de desenvolvimento local:

1. Crie um arquivo .env na raiz do projeto (certifique-se de que está no .gitignore).

2. Adicione suas variáveis de ambiente:

   DATABASE_URL=postgres://user:password@db:5432/myapp
   API_KEY=your_api_key_here

3. No seu docker-compose.yml, referencie o arquivo .env:

   version: '3'
   services:
     app:
       build: .
       env_file: .env

4. Para variáveis específicas do Docker Compose, você pode adicioná-las diretamente no docker-compose.yml:

   services:
     app:
       environment:
         - NODE_ENV=development

Boas práticas para desenvolvimento com Docker:

1. Consistência: Use Docker para garantir que todos os desenvolvedores trabalhem em um ambiente consistente.

2. Isolamento: Mantenha suas dependências isoladas dentro dos containers.

3. Versionamento: Versione seus Dockerfiles e docker-compose.yml junto com o código do projeto.

4. Otimização: Use multi-stage builds para otimizar suas imagens Docker.

5. Segurança: Não armazene segredos ou chaves sensíveis em imagens Docker ou repositórios de código.

Diretrizes adicionais:

1. Logs: Certifique-se de que sua aplicação escreva logs para stdout e stderr, facilitando a coleta de logs pelos sistemas de monitoramento.

2. Healthchecks: Implemente endpoints de healthcheck em suas aplicações para facilitar o monitoramento.

3. Stateless: Projete suas aplicações para serem stateless sempre que possível, facilitando a escalabilidade.

4. Configuração externa: Use variáveis de ambiente ou arquivos de configuração externos para configurações específicas do ambiente.

5. Documentação: Mantenha a documentação atualizada sobre como configurar e executar o ambiente de desenvolvimento local.

Responsabilidades do desenvolvedor:

1. Manter o ambiente Docker local atualizado e funcional.
2. Reportar quaisquer problemas com o ambiente de desenvolvimento à equipe de DevOps.
3. Seguir as melhores práticas de desenvolvimento para containers.
4. Testar thoroughly em seu ambiente local antes de fazer push para o repositório.

Processo de implantação:

Embora a implantação seja gerenciada pela equipe de DevOps, é importante entender o fluxo:

1. Desenvolvedores fazem push do código para o repositório.
2. CI/CD pipeline é acionado (geralmente usando Jenkins ou GitLab CI).
3. Testes automatizados são executados.
4. Se os testes passarem, a aplicação é construída e empacotada em uma imagem Docker.
5. A imagem é enviada para um registro de containers.
6. A equipe de DevOps implanta a nova versão no ambiente de staging para testes finais.
7. Após aprovação, a nova versão é implantada em produção.