Executando verificação de segurança...
1
himmussel
5 min de leitura ·

Adoção da Infraestrutura como Código (IaC)

A adoção de Infraestrutura como Código (IaC) tem se tornado cada vez mais popular entre as organizações devido aos benefícios que oferece. Nesse processo a infraestrutura é descrita e gerenciada através do uso de código, muitas das vezes usando “templates” em linguagens de marcação de forma declarativa, permitindo que as organizações automatizem e otimizem suas infraestruturas de forma eficiente.
Uma das principais vantagens da adoção de IAC é a capacidade de automatizar tarefas manuais e repetitivas, como implantação de recursos e servidores, e até mesmo configurações de sistemas. Isso permite que as equipes de operações e desenvolvimento se concentrem em tarefas de maior valor, como garantir a disponibilidade e escalabilidade da infraestrutura. Além disso, a automatização também ajuda a reduzir erros humanos e melhora a eficiência operacional.
Outra vantagem da adoção de IAC é a capacidade de gerenciar de forma eficiente ambientes híbridos e multi-cloud. Com o uso dessas ferramentas, as organizações podem provisionar recursos em diferentes nuvens e ambientes de forma consistente e automatizada, melhorando a flexibilidade e escalabilidade da infraestrutura.
IAC também permite que as organizações melhorem a segurança e monitoramento de suas infraestruturas. Ao descrever a infraestrutura através do uso de código, as equipes podem identificar e corrigir vulnerabilidades de forma automatizada, além de monitorar o desempenho e a disponibilidade dos recursos.
Algumas ferramentas de IAC se destacam por serem extremamente completas, dentre elas temos: Terraform e Ansible. as quais usaremos no exemplo a seguir. Essas ferramentas permitem que a infraestrutura seja gerenciada de forma eficiente, usando linguagens de programação como Python e HashiCorp Configuration Language (HCL).

O que é Ansible?

O Ansible é uma ferramenta de automação de configuração e gerenciamento de sistemas. Ele permite que você escreva scripts (conhecidos como “playbooks”) que automatizam tarefas comuns, como configurar servidores, instalar softwares e gerenciar usuários. Ele também permite que você gerencie configurações em vários sistemas de forma simultânea, usando uma única ferramenta. Isso pode ajudar a garantir que todos os seus sistemas estejam configurados de forma consistente, e torna mais fácil detectar e corrigir problemas.
Automatize tarefas de forma segura e escalável, aumentando a eficiência operacional e diminuindo erros humanos.

O que é Terraform?

Terraform é uma ferramenta de gerenciamento de infraestrutura como código. Ele permite que você escreva arquivos no formato HCL (templates) que descrevem a infraestrutura que você deseja ter, como servidores, redes e armazenamento. Ele então usa esses scripts para criar e gerenciar essa infraestrutura em diferentes provedores, como AWS, Azure ou GCP. Isso pode ajudar a garantir que sua infraestrutura esteja sempre configurada de forma consistente, e torna mais fácil detectar e corrigir problemas

Mão à massa

Vamos criar um pequeno exemplo pare demostrar o poder dessas ferramentas, a proposta é uma instancia na AWS rodando um servidor web. a ideia é usarmos o terraform para implantar os recursos na AWS e em seguida o ansible para configurar a instancia e torna-la disponível
Primeiramente precisamos garantir que tenhamos instalado e configurado o ansible, terraform, e AWS CLI. os comandos a seguir são para instalação no ubuntu, porem caso não funcionem no seu caso, o processo é bem simples e pode ser encontrado na documentação
Instalar o Ansible: ( link da documentação )

sudo apt-add-repository --yes --update ppa:ansible/ansible
sudo apt-get install ansible
  1. Instalar o Terraform: ( link da documentação )
sudo apt-get update && sudo apt-get install -y gnupg software-properties-common
wget -O- https://apt.releases.hashicorp.com/gpg | \
    gpg --dearmor | \
    sudo tee /usr/share/keyrings/hashicorp-archive-keyring.gpg
gpg --no-default-keyring \
    --keyring /usr/share/keyrings/hashicorp-archive-keyring.gpg \
    --fingerprint
echo "deb [signed-by=/usr/share/keyrings/hashicorp-archive-keyring.gpg] \
    https://apt.releases.hashicorp.com $(lsb_release -cs) main" | \
    sudo tee /etc/apt/sources.list.d/hashicorp.list
sudo apt update && sudo apt-get install terraform
  1. Instalar o AWS CLI: (link da documentação)
sudo apt-get install python3-pip
pip3 install awscli --upgrade --user
# configure as credenciais
aws configure

Feito isso estamos prontos para começar, primeiro crie um arquivo chamado ‘main.tf’, com o seguinte conteúdo:

resource "tls_private_key" "pk" {
 algorithm = "RSA"
 rsa_bits = 4096
}
resource "aws_key_pair" "kp" {
 key_name = "myKey" # Create a "myKey" to AWS!!
 public_key = tls_private_key.pk.public_key_openssh
 provisioner "local-exec" { # Create a "myKey.pem" to your computer!!
 command = <<EOF
 echo '${tls_private_key.pk.private_key_pem}' > ./myKey.pem
 chmod 400 ./myKey.pem
 EOF
 }
}
resource "aws_instance" "ec2Instance" {
 ami = "ami-0ff8a91507f77f867"
 instance_type = "t2.micro"
 key_name = "myKey"
 depends_on = [aws_key_pair.kp]
 provisioner "local-exec" {
 command = <<EOF
 echo conectando a "${self.public_ip}"
 ansible-playbook -i '${self.public_ip},' -u ec2-user --key-file './myKey.pem' playbook.yml
 EOF
 }
}
output "IP" {
 value = "${aws_instance.ec2Instance.public_ip}"
}

esse arquivo é responsável por criar a EC2, a key pair e executar o playbook do ansible, o que nos leva ao proximo arquivo ‘playbook.yml’, crie o arquivo na mesma pasta com o seguinte:

- name: Install and configure Nginx
  hosts: all
  become: true
  tasks:
  - name: Install Nginx
    package:
      name: nginx
      state: present
  - name: Start Nginx
    service:
      name: nginx
      state: started
      enabled: true
  - name: ensure Nginx is running
    shell: service nginx status | grep "running"
    register: nginx_status
    changed_when: false
  - name: check if Nginx is running
    assert:
      that: nginx_status.stdout != ""
      msg: "Nginx is not running"

Certo, hora de testar. agora vamos usar o terraform para criar todos os recursos.

# para inicializar os modulos do terraform
terraform init
#   para visualizar as alterações que serão feitas, essa parte é importante
# para evitar alterações indesejadas
terraform plan -out planA 
## para criar os recursos e configura-los execute:
terraform apply planA

E pronto, você já deve ter uma instancia EC2 rodando um servidor nginx. como vocês devem ter percebido, isso nós permite criar recursos de forma muito mais rápida. espero que tenham gostado do conteúdo, e feedback são muito bem vindos

Carregando publicação patrocinada...