Dê o próximo passo e inicie sua carreira
Dê o próximo passo e inicie sua carreira agora mesmo
8 minutos de leitura
Autor(a)
Fique por dentro de conteúdos, insights e oportunidades do universo tech. Receba novidades e lançamentos direto no seu e-mail.
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.
Engenheiro de Nuvem: o guia da profissão que vem construindo o futuro da TI
Ler mais
Como funciona o modo privado do navegador
Ler mais
Começando com Git: Aprendendo a versionar
Ler mais
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!
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.
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!
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.
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.
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"
}
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"]
}
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"
}
}
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.
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:
Avalie este artigo