Terraform: criando máquinas na Azure

A Azure

Respirar, tomar água, tomar banho são necessidades básicas na vida de cada um, e eu tenho certeza que você já precisou em algum momento recorrer a um serviço de nuvem.

E no mundo de devops, pensou em nuvem, é fácil pensar logo em Azure, um dos maiores provedores de cloud (“nuvem”) atualmente, que fornece várias opções de serviços, não é?

Com a Azure, temos serviços desde infraestrutura, como máquinas virtuais em que podemos colocar os nossos códigos gerindo as atualizações e configurações, até plataformas, como funções serverless e bancos de dados, em que o provedor mantém as configurações e não precisamos nos preocupar.

Até aqui tudo perfeito, hein?

E sim, é possível usar o console da Azure para criar todos esses recursos, porém…. essa não é a melhor maneira de criarmos uma infraestrutura!

Não é a melhor maneira porque, se criarmos a infraestrutura usando o console, não teremos uma documentação do que existe nela…. e assim, fica difícil fazer alterações.

Além disso, não temos a possibilidade de recriar a infraestrutura de forma fácil e rápida para usarmos a mesma infraestrutura em dois ambientes.

Mas então, o que fazer???

Relaxa: uma solução é criarmos a infraestrutura usando códigos, e para isso podemos usar o… Terraform!

Terraform

O Terraform é uma ferramenta de infraestrutura como código muito utilizada atualmente por permitir a conexão com vários provedores diferentes para criar e configurar a infraestrutura através de código.

Assim, podemos fazer alterações e replicar o ambiente de forma rápida.

Benzadeus esse Terraform, hein?

Mas, peraí… por que usar uma ferramenta como o Terraform, que tem uma linguagem própria quando podemos usar um script bash, que usa comandos do terminal para montar a infraestrutura?

Quando usamos um script bash, por exemplo, perdemos a idempotência, ou seja, pode ser que ao executarmos ele múltiplas vezes, as máquinas acabam sendo criadas duas vezes ou não sendo criadas por algum erro que não detectamos.

O Terraform já foi construído com a idempotência em mente, onde podemos executar o código quantas vezes você quiser e sempre teremos o mesmo resultado.

Logo, não precisamos nos preocupar com isso, e por ser uma linguagem padronizada não precisamos ficar coçando a cabeça para entender o que outro desenvolvedor fez , já que temos apenas uma maneira de criar um recurso.

Características da Azure

Voltando a falar da Azure, diferente de outros provedores, ela não te entrega uma VPC padrão com a sua conta, então para poder começar a utilizá-la é necessário criar uma VPC.

A VPC é a Virtual Private Cloud, ou em português, Cloud Virtual Privado.

Ao invés de precisarmos criar uma conta para cada projeto, podemos criar uma VPC para cada projeto, mantendo-os isolados e seguros uns dos outros.

Assim, caso tenhamos um problema de segurança em um projeto, os dados do outro projeto se mantêm seguros.

Os nomes dos recursos também são diferentes entre os provedores, então as máquinas virtuais que criamos na AWS, outro grande provedor, com o nome aws_instance, ou instância da AWS, passam a ter o nome de azurerm_virtual_machine.

Bom, agora que você já entendeu mais da teoria…. vamos pra prática? Afinal, o objetivo é você criar máquinas na Azure, por meio do TerraForm!

Mão na massa

Preparando o ambiente

Para podermos criar a nossa infraestrutura na Azure temos que configurar ela como um provedor de recursos e a equipe do Terraform já deixou um guia para nos ajudar nessa etapa.

Para acessar o guia, basta clicar aqui ou ir até o site do terraform. Em seguida, clicar em tutoriais, usando a barra lateral esquerda, clicar em Azure e em “Build Infrastructure - Terraform Azure Example” e seguir os passos informados.

Máquina virtual

Vamos criar uma máquina virtual na Azure para treinar. É uma boa ideia usar a documentação ao nosso favor.

Vamos começar criando a máquina virtual, ela é composta de várias partes. Então vamos começar com as configurações gerais:

resource "azurerm_virtual_machine" "main" {
  name                  = "primeira-vm"
  location              = 
  resource_group_name   = 
  network_interface_ids = 
  vm_size               = "Standard_DS1_v2"

As configurações gerais incluem o nome e o tamanho da VM, porém a localização, o grupo de recursos e a interface de rede ainda precisam ser criados.

As VMs da Azure são definidas de acordo com a documentação de convenção e as familias de maquinas estão descritas na documentação de tamanhos.

A seguir temos que especificar qual sistema iremos usar, nesse caso vamos usar o Ubuntu server 20.04 LTS:

  storage_image_reference {
    publisher = "Canonical"
    offer     = "UbuntuServer"
    sku       = "20.04-LTS"
    version   = "latest"
  }

Com o sistema especificado, podemos criar um disco para essa máquina, esse disco precisa de um nome e um tipo de criação:

  storage_os_disk {
    name              = "meudisco1"
    caching           = "ReadWrite"
    create_option     = "FromImage"
    managed_disk_type = "Standard_LRS"
  }

Acabamos dando o nome de meudisco1 e o tipo de criação foi definido através do padrão da imagem, também é possível criar um disco vazio ou usar um disco já existente.

A seguir temos que preparar as configurações para usarmos o sistema na máquina virtual:

  os_profile {
    computer_name  = "vm-azure"
    admin_username = "Alura"
    admin_password = "Alura1234!"
  }
  os_profile_linux_config {
    disable_password_authentication = false
  }
}

Com o nome do computador, o usuário do administrador e a senha definida podemos seguir para a criação dos outros recursos necessários.

Uma boa prática seria não deixar o nome de usuário e senha preenchidos nesse arquivo e colocarmos eles como variáveis com valores definidos em um arquivo que não seja salvo em um repositório, assim aumentamos a segurança das máquinas e dos dados que eles processam.

Outra opção é colocar disable_password_authentication = true e usar chaves SSH com ssh_keys, que também não devem ser salvas nos repositórios.

Grupo de recursos

O grupo de recursos é o local onde todos os nossos recursos devem ficar, então as nossas VMs, as interfaces de rede, as redes virtuais e assim por diante.

Ele faz o isolamento entre as aplicações e a proteção para um problema de segurança de uma aplicação não influencie outra, além disso ele define os locais onde os recursos são criados.

Para criarmos ele basta especificarmos um nome e o local, os locais disponiveis podem ser encontrado aqui.

resource "azurerm_resource_group" "grupo" {
  name     = "recursos"
  location = "East US"
}

Rede virtual

Precisamos agora criar uma rede que vai interligar as nossas máquinas e recursos, e permitir que todos os recursos possam receber e responder requisições.

Para criarmos essa rede virtual, precisamos de um nome, um conjunto de endereços IP privados e do grupo de recursos.

resource "azurerm_virtual_network" "main" {
  name                = "rede-privada"
  address_space       = ["10.0.0.0/16"]
  location            = azurerm_resource_group.grupo.location
  resource_group_name = azurerm_resource_group.grupo.name
}

Dentro dessa rede é necessário ao menos uma subnet, que também precisa de um nome e um conjunto de IPs que estejam dentro do conjunto da rede.

resource "azurerm_subnet" "interna" {
  name                 = "interna"
  resource_group_name  = azurerm_resource_group.grupo.name
  virtual_network_name = azurerm_virtual_network.main.name
  address_prefixes     = ["10.0.1.0/24"]
}

Interface de rede

O último recurso que precisamos criar é uma interface de rede para que os recursos possam se comunicar com a rede virtual.

Essa interface precisa de um nome e algumas configurações de IP, como a id da subnet e que tipo de IP vai ser alocado, dinâmico ou fixo.

resource "azurerm_network_interface" "main" {
  name                = "meu-nic"
  location            = azurerm_resource_group.grupo.location
  resource_group_name = azurerm_resource_group.grupo.name
ip_configuration {
name                          = "teste1"
subnet_id                     = azurerm_subnet.interna.id
private_ip_address_allocation = "Dynamic"
}
}

Código completo

Agora que temos todas as partes para criar a nossa máquina virtual, podemos preencher os campos que ficaram faltando e teremos esse código:

resource "azurerm_virtual_machine" "main" {
  name                  = "primeira-vm"
  location              = azurerm_resource_group.grupo.location
  resource_group_name   = azurerm_resource_group.grupo.name
  network_interface_ids = [azurerm_network_interface.main.id]
  vm_size               = "Standard_DS1_v2"
  storage_image_reference {
    publisher = "Canonical"
    offer     = "UbuntuServer"
    sku       = "20.04-LTS"
    version   = "latest"
  }
  storage_os_disk {
    name              = "meudisco1"
    caching           = "ReadWrite"
    create_option     = "FromImage"
    managed_disk_type = "Standard_LRS"
  }
  os_profile {
    computer_name  = "vm-azure"
    admin_username = "Alura"
    admin_password = "Alura1234!"
  }
  os_profile_linux_config {
    disable_password_authentication = false
  }
}


resource "azurerm_resource_group" "grupo" {
name     = "recursos"
location = "East US"
}




resource "azurerm_virtual_network" "main" {
name                = "rede-privada"
address_space       = ["10.0.0.0/16"]
location            = azurerm_resource_group.grupo.location
resource_group_name = azurerm_resource_group.grupo.name
}




resource "azurerm_subnet" "interna" {
name                 = "interna"
resource_group_name  = azurerm_resource_group.grupo.name
virtual_network_name = azurerm_virtual_network.main.name
address_prefixes     = ["10.0.1.0/24"]
}




resource "azurerm_network_interface" "main" {
name                = "meu-nic"
location            = azurerm_resource_group.grupo.location
resource_group_name = azurerm_resource_group.grupo.name


ip_configuration {
name                          = "teste1"
subnet_id                     = azurerm_subnet.interna.id
private_ip_address_allocation = "Dynamic"
}
}

Agora, podemos usar o terraform up para criar essa infraestrutura e o terraform destroy para apagá-la, lembrando que criar a infraestrutura em algum provedor pode gerar custos.

Conclusão

Acabamos de ver como podemos criar uma máquina virtual na Azure e todos os recursos que são necessários para poder criá-la, tudo isso através de código.

Isso possibilitou a criação e a replicação da infraestrutura de forma rápida. E aí, curtiu?

Para aprender mais sobre infraestrutura como código, confira abaixo os links:

• Formação de infraestrutura como código
• Cursos de infraestrutura como código Alura