O que é Infraestrutura como Código (IaC)
Infraestrutura como Código é a prática de gerenciar e provisionar infraestrutura através de arquivos de configuração legíveis por máquina, em vez de processos manuais. Você define servidores, redes, bancos de dados e outros recursos em código versionado, permitindo automação, repetibilidade e rastreabilidade completa das mudanças.
Essa abordagem resolve problemas clássicos: ambientes inconsistentes ("funciona na minha máquina"), documentação desatualizada e deploys lentos e propensos a erros. Como desenvolvedor, você ganha a capacidade de replicar ambientes inteiros em minutos e colaborar com infraestrutura assim como faz com código-fonte.
Por que todo dev deve aprender IaC
Já passou o tempo em que infraestrutura era responsabilidade exclusiva de DevOps. Hoje, desenvolvedores precisam entender como suas aplicações rodam, escalam e se comunicam com outros serviços. IaC democratiza esse conhecimento: você escreve uma vez, versiona no Git e o ambiente é provisionado identicamente em produção.
Principais Ferramentas e Linguagens
Terraform
Terraform é agnóstico de provedor (funciona com AWS, Azure, GCP, Kubernetes). Usa HCL (HashiCorp Configuration Language), uma sintaxe declarativa que descreve o estado final desejado, não passos imperativs.
# exemplo: criar instância EC2 na AWS
provider "aws" {
region = "us-east-1"
}
resource "aws_instance" "servidor_app" {
ami = "ami-0c55b159cbfafe1f0"
instance_type = "t3.micro"
tags = {
Name = "servidor-producao"
}
}
output "endereco_ip" {
value = aws_instance.servidor_app.public_ip
}
O fluxo é simples: terraform plan mostra o que será criado, terraform apply executa e terraform destroy remove tudo. O estado fica salvo localmente ou em backends remotos (S3, Terraform Cloud).
CloudFormation e ARM Templates
Se você trabalha exclusivamente com AWS, CloudFormation é nativa e poderosa. Azure oferece ARM Templates. Ambas usam JSON ou YAML. A vantagem é integração profunda; a desvantagem é lock-in de provedor.
# CloudFormation: criar VPC e Security Group
AWSTemplateFormatVersion: '2010-09-09'
Resources:
MinhaVPC:
Type: AWS::EC2::VPC
Properties:
CidrBlock: 10.0.0.0/16
EnableDnsHostnames: true
GrupoSeguranca:
Type: AWS::EC2::SecurityGroup
Properties:
GroupDescription: "Permite HTTP e HTTPS"
VpcId: !Ref MinhaVPC
SecurityGroupIngress:
- IpProtocol: tcp
FromPort: 80
ToPort: 80
CidrIp: 0.0.0.0/0
Ansible
Ansible é imperativo e mais simples para iniciantes. Executa tarefas em sequência contra máquinas já provisionadas. Ideal para configuração, deploy de aplicações e orquestração.
# playbook ansible: instalar e iniciar nginx
---
- hosts: servidores_web
become: yes
tasks:
- name: Instalar Nginx
apt:
name: nginx
state: present
- name: Garantir Nginx iniciado
service:
name: nginx
state: started
enabled: yes
- name: Copiar configuração customizada
copy:
src: ./nginx.conf
dest: /etc/nginx/nginx.conf
notify: restart nginx
handlers:
- name: restart nginx
service:
name: nginx
state: restarted
Boas Práticas Essenciais
Versionamento e Controle de Mudanças
Todo arquivo de IaC deve estar no Git. Crie branches para mudanças, revise em pull requests e mantenha histórico limpo. Nunca faça mudanças manuais na infraestrutura em produção — sempre passe pelo código.
# workflow típico
git checkout -b feature/nova-db
# edita arquivo terraform
git add .
git commit -m "feat: adicionar RDS PostgreSQL com backup automático"
git push origin feature/nova-db
# Pull Request → Code Review → Merge → CI/CD aplica mudança
Separação de Ambientes
Organize código em diretórios ou workspaces diferentes para dev, staging e produção. Variáveis devem ser externalizadas em arquivos .tfvars ou ambiente.
# main.tf
variable "ambiente" {
type = string
}
variable "tamanho_instancia" {
type = string
default = var.ambiente == "prod" ? "t3.large" : "t3.micro"
}
resource "aws_instance" "app" {
instance_type = var.tamanho_instancia
tags = {
Ambiente = var.ambiente
}
}
Idempotência e Documentação
Código IaC deve ser idempotente: executar duas vezes produz o mesmo resultado. Documente variáveis, outputs e decisões de arquitetura. Use nomes descritivos para recursos.
Dica prática: Destrua e recrie sua infraestrutura regularmente em homolog. Se alguma coisa falhar, o problema aparece rápido e você aprende a usar o código efetivamente.
Integração com Pipeline CI/CD
IaC sem automação é apenas meia vitória. Configure seu CI/CD para validar, testar e aplicar mudanças automaticamente.
# .github/workflows/deploy-infra.yml (GitHub Actions)
name: Deploy Infraestrutura
on:
push:
branches: [main]
paths: ['terraform/**']
jobs:
deploy:
runs-on: ubuntu-latest
steps:
- uses: actions/checkout@v3
- name: Setup Terraform
uses: hashicorp/setup-terraform@v2
with:
terraform_version: 1.5.0
- name: Validar Terraform
run: terraform -chdir=terraform validate
- name: Planejar mudanças
run: terraform -chdir=terraform plan -out=tfplan
- name: Aplicar
run: terraform -chdir=terraform apply tfplan
Integre também testes de segurança (Checkov, TFLint) e testes de conformidade antes de aplicar. Isso previne configurações inseguras ou não-conformes em produção.
Conclusão
Aprender IaC é investimento estratégico na sua carreira. Primeiro, escolha uma ferramenta (Terraform é versátil e agnóstico); segundo, implemente separação de ambientes e versionamento rigoroso; terceiro, integre com CI/CD para eliminar deploys manuais. A partir daí, infraestrutura vira um problema resolvido, e você foca no que realmente importa: código de qualidade.