DevOps

Como aplicar o princípio da infraestrutura imutável em um ambiente DevOps

Virgílio Borges

• 8 min read
Como aplicar o princípio da infraestrutura imutável em um ambiente DevOps

A infraestrutura imutável é uma abordagem que visa tornar os componentes de infraestrutura inalteráveis, ou seja, que não podem ser modificados depois de implantados. Isso significa que, em vez de atualizar ou corrigir os servidores, containers ou outros recursos em execução, eles são substituídos por novas versões sempre que houver uma mudança. Neste artigo, vamos explicar o que é infraestrutura imutável, quais são os benefícios e desafios dessa abordagem e como aplicá-la em um ambiente DevOps.

O que é infraestrutura imutável?

A infraestrutura imutável é baseada no conceito de imutabilidade, que é uma propriedade de algo que não pode ser alterado ou modificado. Por exemplo, uma string é um tipo de dado imutável, pois uma vez criada, ela não pode ser modificada. Se quisermos alterar o valor de uma string, temos que criar uma nova string com o novo valor.

A infraestrutura imutável aplica esse conceito aos componentes de infraestrutura, como servidores, containers, máquinas virtuais, redes, etc. Em uma infraestrutura imutável, esses componentes são criados a partir de imagens pré-configuradas e pré-testadas, que contêm todas as dependências e configurações necessárias para executar as aplicações. Essas imagens são armazenadas em um repositório centralizado e versionado, e podem ser facilmente replicadas e distribuídas.

Uma vez implantados, esses componentes não são mais alterados manualmente ou por meio de ferramentas de gerenciamento de configuração. Eles permanecem no mesmo estado até serem descartados e substituídos por novos componentes criados a partir de novas imagens. Essa substituição ocorre sempre que há uma mudança no código da aplicação, nas configurações da infraestrutura ou nas políticas de segurança.

Quais são os benefícios da infraestrutura imutável?

A infraestrutura imutável traz diversos benefícios para o ambiente DevOps, tais como:

  • Consistência: ao usar imagens pré-configuradas e pré-testadas para criar os componentes de infraestrutura, evita-se o risco de inconsistências entre os ambientes de desenvolvimento, teste e produção. Todos os componentes têm o mesmo estado e comportamento esperado, o que facilita a depuração e a resolução de problemas.
  • Confiabilidade: ao eliminar as mudanças nos componentes em execução, reduz-se a possibilidade de erros humanos ou falhas nas ferramentas de gerenciamento de configuração. Além disso, ao descartar os componentes antigos e substituí-los por novos, evita-se o acúmulo de lixo ou vulnerabilidades nos sistemas operacionais ou nas aplicações.
  • Segurança: ao usar imagens atualizadas e seguras para criar os componentes de infraestrutura, garante-se que eles estejam em conformidade com as políticas e normas de segurança. Além disso, ao substituir os componentes periodicamente, reduz-se a exposição a ataques ou invasões.
  • Agilidade: ao automatizar o processo de criação e substituição dos componentes de infraestrutura, acelera-se o ciclo de vida das aplicações. Isso permite entregar valor aos clientes com mais rapidez e frequência, além de facilitar a integração e a entrega contínuas (CI/CD).

Quais são os desafios da infraestrutura imutável?

A infraestrutura imutável também apresenta alguns desafios que devem ser considerados antes de adotá-la, tais como:

  • Custo: ao substituir os componentes de infraestrutura com frequência, pode-se aumentar o consumo de recursos computacionais e o armazenamento das imagens. Isso pode gerar um custo maior para a organização, especialmente se ela usa serviços em nuvem. Por isso, é importante planejar bem a capacidade e a escalabilidade da infraestrutura, além de monitorar e otimizar o uso dos recursos.
  • Complexidade: ao usar imagens pré-configuradas e pré-testadas para criar os componentes de infraestrutura, é preciso garantir que elas estejam sempre atualizadas e compatíveis com as aplicações. Isso requer um processo rigoroso de controle de versão, teste e validação das imagens, além de uma boa comunicação entre as equipes de desenvolvimento e operações. Além disso, é preciso definir uma estratégia de backup e recuperação dos dados, pois os componentes são descartados com frequência.
  • Cultura: ao adotar a infraestrutura imutável, é preciso mudar a mentalidade e os hábitos das equipes de desenvolvimento e operações, que estão acostumadas a modificar os componentes em execução. Isso requer uma cultura de colaboração, automação e aprendizado contínuo, além de uma visão compartilhada dos objetivos e benefícios da infraestrutura imutável.

Como aplicar o princípio da infraestrutura imutável em um ambiente DevOps?

Para aplicar o princípio da infraestrutura imutável em um ambiente DevOps, é preciso seguir alguns passos, que podem variar de acordo com as características e necessidades de cada organização. A seguir, apresentamos um exemplo genérico de como aplicar a infraestrutura imutável em um ambiente DevOps:

  • Definir as imagens: o primeiro passo é definir as imagens que serão usadas para criar os componentes de infraestrutura. As imagens devem conter todas as dependências e configurações necessárias para executar as aplicações, como o sistema operacional, os pacotes, os drivers, os scripts, etc. As imagens podem ser criadas manualmente ou por meio de ferramentas de automação, como o Packer1.
  • Armazenar as imagens: o segundo passo é armazenar as imagens em um repositório centralizado e versionado, que permita o acesso e a distribuição das imagens pelas equipes de desenvolvimento e operações. O repositório deve ter mecanismos de segurança, como autenticação, criptografia e assinatura digital. O repositório pode ser local ou em nuvem, como o Amazon Elastic Container Registry (ECR)2 ou o Azure Container Registry (ACR)3.
  • Testar as imagens: o terceiro passo é testar as imagens antes de implantá-las na infraestrutura. Os testes devem verificar se as imagens estão funcionando corretamente e se estão em conformidade com os requisitos funcionais e não funcionais das aplicações. Os testes podem ser realizados manualmente ou por meio de ferramentas de automação, como o Testinfra4 ou o Serverspec5.
  • Implantar as imagens: o quarto passo é implantar as imagens na infraestrutura, criando os componentes correspondentes, como servidores, containers ou máquinas virtuais. A implantação deve ser feita por meio de ferramentas de automação, que permitem provisionar, configurar e gerenciar os componentes de forma rápida e consistente. Algumas ferramentas que podem ser usadas são o Terraform6, o Ansible7 ou o Chef8.
  • Substituir os componentes: o quinto passo é substituir os componentes sempre que houver uma mudança nas aplicações ou nas configurações da infraestrutura. A substituição deve ser feita por meio de ferramentas de automação, que permitem criar novos componentes a partir das novas imagens e descartar os componentes antigos sem interromper o serviço. Algumas ferramentas que podem ser usadas são o Kubernetes, o Docker Swarm ou o Amazon Elastic Container Service (ECS).

Para aplicar o princípio da infraestrutura imutável em um ambiente DevOps, você pode seguir os seguintes passos:

  • Criar uma imagem do seu aplicativo que contenha todas as dependências e configurações necessárias para executá-lo. Você pode usar ferramentas como o Docker1 ou o Packer2 para criar imagens de containers ou de máquinas virtuais, respectivamente.
  • Armazenar a imagem do seu aplicativo em um repositório centralizado e versionado, que permita o acesso e a distribuição das imagens pelas equipes de desenvolvimento e operações. Você pode usar serviços em nuvem como o Amazon Elastic Container Registry (ECR)3 ou o Azure Container Registry (ACR)4 para armazenar imagens de containers, por exemplo.
  • Testar a imagem do seu aplicativo antes de implantá-la na infraestrutura. Você pode usar ferramentas como o Testinfra ou o Serverspec para escrever e executar testes de infraestrutura usando Python ou Ruby, respectivamente.
  • Implantar a imagem do seu aplicativo na infraestrutura, criando os componentes correspondentes, como servidores, containers ou máquinas virtuais. Você pode usar ferramentas como o Terraform, o Ansible ou o Chef para provisionar, configurar e gerenciar a infraestrutura como código.
  • Substituir os componentes da infraestrutura sempre que houver uma mudança no seu aplicativo ou nas configurações da infraestrutura. Você pode usar ferramentas como o Kubernetes, o Docker Swarm ou o Amazon Elastic Container Service (ECS) para criar e gerenciar clusters de containers que podem ser substituídos facilmente.

Um exemplo simples de infraestrutura imutável é usar uma imagem do Linux que já contém o Apache instalado e configurado para servir uma página web estática. Neste caso, você não precisa modificar o servidor depois de criá-lo, apenas substituí-lo por uma nova imagem quando precisar atualizar o Apache ou o Linux. Um exemplo de código que usa o Docker e o Terraform para criar e gerenciar essa infraestrutura imutável é o seguinte:

# Definir o provedor de infraestrutura como AWS
provider "aws" {
  region = "us-east-1"
}

# Definir um recurso do tipo aws_instance, que representa uma instância EC2
resource "aws_instance" "web-server" {
  ami           = "ami-0c2b8ca1dad447f8a" # AMI do Amazon Linux 2
  instance_type = "t2.micro"
  # Instalar e executar o Docker na instância
  user_data = <<EOF
    #!/bin/bash
    sudo yum update -y
    sudo amazon-linux-extras install docker -y
    sudo service docker start
    sudo usermod -a -G docker ec2-user
    # Criar uma imagem do Docker com o Apache e uma página web estática
    sudo docker build -t web-image .
    # Executar um container com a imagem do Docker e expor a porta 80
    sudo docker run -d -p 80:80 web-image
    EOF
  # Permitir o acesso à porta 80 da instância
  security_groups = ["${aws_security_group.web-sg.name}"]
}

# Definir um recurso do tipo aws_security_group, que representa um grupo de segurança
resource "aws_security_group" "web-sg" {
  name        = "web-sg"
  description = "Allow access to port 80"
  # Permitir o acesso à porta 80 da instância de qualquer origem
  ingress {
    from_port   = 80
    to_port     = 80
    protocol    = "tcp"
    cidr_blocks = ["0.0.0.0/0"]
  }
}

# Definir um arquivo chamado Dockerfile, que contém as instruções para construir a imagem do Docker com o Apache e uma página web estática
data "template_file" "Dockerfile" {
  template = <<DOCKERFILE
    # Use a imagem oficial do CentOS 7 como base
    FROM centos:7

    # Instale o Apache usando o yum
    RUN yum -y update && yum -y install httpd

    # Copie a página web estática para o diretório /var/www/html
    COPY index.html /var/www/html/

    # Exponha a porta 80 do container
    EXPOSE 80

    # Inicie o Apache quando o container iniciar
    CMD ["/usr/sbin/httpd", "-D", "FOREGROUND"]
  DOCKERFILE
}

# Definir um arquivo chamado index.html, que contém o código HTML da página web estática
data "template_file" "index" {
  template = <<HTML
    <html>
      <head>
        <title>Web Server</title>
      </head>
      <body>
        <h1>Hello, world!</h1>
        <p>This is a web server running on an immutable infrastructure.</p>
      </body>
    </html>
  HTML
}

O código usa o Docker para criar uma imagem com o Apache e uma página web estática, e o Terraform para criar uma instância EC2 que executa um container com essa imagem e expõe a porta 80. Para acessar a página web, basta usar o endereço IP da instância.

Conclusão

Neste artigo, vimos como aplicar o princípio da infraestrutura imutável em um ambiente DevOps. Aprendemos o que é infraestrutura imutável, quais são os benefícios e desafios dessa abordagem e como aplicá-la em um ambiente DevOps. Vimos também alguns exemplos de ferramentas que podem nos auxiliar nesse processo.

A infraestrutura imutável é uma abordagem que visa aumentar a consistência, a confiabilidade, a segurança e a agilidade da infraestrutura, evitando as mudanças nos componentes em execução e substituindo-os por novas versões sempre que houver uma alteração. Para aplicar essa abordagem em um ambiente DevOps, é preciso usar ferramentas de automação que permitam criar, armazenar, testar e implantar imagens pré-configuradas e pré-testadas dos componentes de infraestrutura. Assim, é possível entregar valor aos clientes com mais rapidez e qualidade, além de facilitar a integração e a entrega contínuas (CI/CD).

Referências Bibliográficas

  • Docker Documentation - https://docs.docker.com/
  • Packer Documentation - https://www.packer.io/docs
  • Amazon Elastic Container Registry (ECR) - https://aws.amazon.com/ecr/
  • Azure Container Registry (ACR) - https://azure.microsoft.com/en-us/services/container-registry/
  • Testinfra Documentation - https://testinfra.readthedocs.io/en/latest/
  • Serverspec Documentation - https://serverspec.org/
  • Terraform Documentation - https://www.terraform.io/docs/index.html
  • Ansible Documentation - https://docs.ansible.com/ansible/latest/index.html
  • Chef Documentation - https://docs.chef.io/

💡
As opiniões e comentários expressos neste artigo são de propriedade exclusiva de seu autor e não representam necessariamente o ponto de vista da Revelo.

A Revelo Content Network acolhe todas as raças, etnias, nacionalidades, credos, gêneros, orientações, pontos de vista e ideologias, desde que promovam diversidade, equidade, inclusão e crescimento na carreira dos profissionais de tecnologia.