Este laboratório foi desenvolvido com nossa parceira, a Hashicorp (link em inglês). Suas informações pessoais podem ser compartilhadas com a Hashicorp, patrocinadora do laboratório, caso você tenha optado por receber atualizações de produtos, anúncios e ofertas em seu perfil de conta.

GSP750

Informações gerais

O Terraform é um produto de infraestrutura como código desenvolvido pela HashiCorp. É uma ferramenta para criar, alterar e gerenciar infraestrutura de maneira segura e repetível. Os operadores e as equipes de infraestrutura podem usar o Terraform para gerenciar ambientes com uma linguagem de configuração chamada HCL (Linguagem de Configuração da HashiCorp) para implantações legíveis e automatizadas.

A Infraestrutura como código é o processo de gerenciar a infraestrutura usando um ou vários arquivos em vez de configurar manualmente os recursos em uma interface do usuário. Um recurso nesta instância é uma parte de infraestrutura em um determinado ambiente, como uma máquina virtual, um grupo de segurança, uma interface de rede etc. Em alto nível, o Terraform permite que os operadores usem a HCL para criar arquivos que contêm definições dos recursos desejados em quase qualquer provedor (AWS, Google Cloud, GitHub, Docker etc.) e automatiza a criação desses recursos no momento da aplicação.

Um fluxo de trabalho simples para implantação acompanhará de perto as etapas abaixo:

• Escopo - Confirme quais recursos precisam ser criados para um projeto.
• Autoria - Crie o arquivo de configuração em HCL com base nos parâmetros com escopo.
• Inicializar - Execute terraform init no diretório do projeto com os arquivos de configuração. Isso fará o download dos plug-ins de provedor corretos para o projeto.
• Planejar e Aplicar - Execute terraform plan para verificar o processo de criação e, em seguida, terraform apply para criar recursos reais além do arquivo de estado que compara alterações futuras nos arquivos de configuração com o que realmente existe no ambiente de implantação.

Objetivos

Neste laboratório, você vai aprender a fazer o seguinte:

• Criar, alterar e destruir a infraestrutura com o Terraform
• Criar dependências de recursos com o Terraform
• Provisionar infraestrutura com o Terraform

Configuração e requisitos

Antes de clicar no botão Start Lab

Leia estas instruções. Os laboratórios são cronometrados e não podem ser pausados. O timer é iniciado quando você clica em Começar o laboratório e mostra por quanto tempo os recursos do Google Cloud vão ficar disponíveis.

Este laboratório prático permite que você realize as atividades em um ambiente real de nuvem, não em uma simulação ou demonstração. Você vai receber novas credenciais temporárias para fazer login e acessar o Google Cloud durante o laboratório.

Confira os requisitos para concluir o laboratório:

• Acesso a um navegador de Internet padrão (recomendamos o Chrome).

Observação: para executar este laboratório, use o modo de navegação anônima ou uma janela anônima do navegador. Isso evita conflitos entre sua conta pessoal e a conta de estudante, o que poderia causar cobranças extras na sua conta pessoal.

• Tempo para concluir o laboratório---não se esqueça: depois de começar, não será possível pausar o laboratório.

Observação: não use seu projeto ou conta do Google Cloud neste laboratório para evitar cobranças extras na sua conta.

Como iniciar seu laboratório e fazer login no console do Google Cloud

1. Clique no botão Começar o laboratório. Se for preciso pagar, você verá um pop-up para selecionar a forma de pagamento. No painel Detalhes do laboratório à esquerda, você vai encontrar o seguinte:

   • O botão Abrir console do Google Cloud
   • O tempo restante
   • As credenciais temporárias que você vai usar neste laboratório
   • Outras informações, se forem necessárias

2. Se você estiver usando o navegador Chrome, clique em Abrir console do Google Cloud ou clique com o botão direito do mouse e selecione Abrir link em uma janela anônima.

   O laboratório ativa os recursos e depois abre a página Fazer login em outra guia.

   Dica: coloque as guias em janelas separadas lado a lado.

   Observação: se aparecer a caixa de diálogo Escolher uma conta, clique em Usar outra conta.

3. Se necessário, copie o Nome de usuário abaixo e cole na caixa de diálogo Fazer login.

   {{{user_0.username | "Nome de usuário"}}}

   Você também encontra o Nome de usuário no painel Detalhes do laboratório.

4. Clique em Seguinte.

5. Copie a Senha abaixo e cole na caixa de diálogo de boas-vindas.

   {{{user_0.password | "Senha"}}}

   Você também encontra a Senha no painel Detalhes do laboratório.

6. Clique em Seguinte.

   Importante: você precisa usar as credenciais fornecidas no laboratório, e não as da sua conta do Google Cloud. Observação: se você usar sua própria conta do Google Cloud neste laboratório, é possível que receba cobranças adicionais.

7. Acesse as próximas páginas:

   • Aceite os Termos e Condições.
   • Não adicione opções de recuperação nem autenticação de dois fatores (porque essa é uma conta temporária).
   • Não se inscreva em testes gratuitos.

Depois de alguns instantes, o console do Google Cloud será aberto nesta guia.

Observação: clique em Menu de navegação no canto superior esquerdo para acessar uma lista de produtos e serviços do Google Cloud.

Ativar o Cloud Shell

O Cloud Shell é uma máquina virtual com várias ferramentas de desenvolvimento. Ele tem um diretório principal permanente de 5 GB e é executado no Google Cloud. O Cloud Shell oferece acesso de linha de comando aos recursos do Google Cloud.

1. Clique em Ativar o Cloud Shell na parte de cima do console do Google Cloud.

Depois de se conectar, vai notar que sua conta já está autenticada, e que o projeto está configurado com seu PROJECT_ID. A saída contém uma linha que declara o projeto PROJECT_ID para esta sessão:

Your Cloud Platform project in this session is set to YOUR_PROJECT_ID

gcloud é a ferramenta de linha de comando do Google Cloud. Ela vem pré-instalada no Cloud Shell e aceita preenchimento com tabulação.

2. (Opcional) É possível listar o nome da conta ativa usando este comando:

gcloud auth list

3. Clique em Autorizar.

4. A saída será parecida com esta:

Saída:

ACTIVE: * ACCOUNT: student-01-xxxxxxxxxxxx@qwiklabs.net To set the active account, run: $ gcloud config set account `ACCOUNT`

5. (Opcional) É possível listar o ID do projeto usando este comando:

gcloud config list project

Saída:

[core] project = <project_ID>

Exemplo de saída:

[core] project = qwiklabs-gcp-44776a13dea667a6 Observação: para conferir a documentação completa da gcloud, acesse o guia com informações gerais sobre a gcloud CLI no Google Cloud.

Tarefa 1. Criar a infraestrutura

O Terraform vem pré-instalado no Cloud Shell. Com ele já instalado, você pode começar a criar uma infraestrutura.

Comece criando um exemplo de configuração para um arquivo chamado main.tf. O Terraform reconhece arquivos que terminam em .tf ou .tf.json como arquivos de configuração e vai carregá-los na execução.

1. Crie o arquivo main.tf:

touch main.tf

2. Clique no botão Abrir editor na barra de ferramentas do Cloud Shell. É possível alternar entre o Cloud Shell e o editor de código usando os ícones Abrir editor e Abrir terminal, conforme necessário. Outra opção é clicar no botão Abrir em uma nova janela para deixar o Editor aberto em uma guia separada.

3. No Editor, adicione o conteúdo abaixo ao arquivo main.tf.

terraform { required_providers { google = { source = "hashicorp/google" version = "3.5.0" } } } provider "google" { project = "{{{project_0.project_id | PROJECT ID}}}" region = "{{{project_0.default_region | REGION}}}" zone = "{{{project_0.default_zone | ZONE}}}" } resource "google_compute_network" "vpc_network" { name = "terraform-network" } Observação: para usar esse snippet com o Terraform 0.12, remova o bloco terraform {}.

Bloco do Terraform

O bloco terraform {} é necessário para que o Terraform saiba de qual provedor fazer download do Registro do Terraform. Na configuração acima, a origem do provedor google é definida como hashicorp/google, que é a abreviação de registry.terraform.io/hashicorp/google.

Você também pode atribuir uma versão a cada provedor definido no bloco required_providers. O argumento version é opcional, embora seja recomendado. Ele é usado para limitar o provedor a uma versão específica ou a um intervalo de versões e, assim, impedir o download de um novo provedor que pode conter alterações interruptivas. Se a versão não for especificada, o Terraform vai fazer automaticamente o download do provedor mais recente durante a inicialização.

Para mais informações, consulte a página Requisitos do provedor no site do HashiCorp Terraform.

Provedores

O bloco provider é usado para configurar o provedor designado, neste caso, google. Um provedor é responsável pela criação e gerenciamento de recursos. Se uma configuração do Terraform gerenciar recursos de diferentes provedores, é possível que existam vários blocos de provedores.

Inicialização

O primeiro comando a ser executado para uma nova configuração -- ou depois de verificar uma configuração já existente do controle de versões -- é terraform init, que inicializa várias configurações locais e os dados que serão usados por comandos posteriores.

• Inicialize a nova configuração do Terraform executando o comando terraform init no mesmo diretório que o arquivo main.tf:

terraform init

Criação de recursos

1. Aplique a configuração agora executando o comando terraform apply:

terraform apply

A saída tem um sinal de + ao lado do recurso "google_compute_network" "vpc_network", o que significa que o Terraform vai criar esse recurso. Abaixo disso, são mostrados os atributos que serão definidos. Quando o valor exibido é (known after apply) quer dizer que o valor não será conhecido até o recurso ser criado.

Se o plano tiver sido criado corretamente, o Terraform aguardará a aprovação para prosseguir. Cancele a operação neste ponto sem fazer nenhuma alteração na infraestrutura se alguma coisa parecer errada ou perigosa.

Se terraform apply tiver falhado com um erro, leia a mensagem de erro e corrija-o.

2. O plano parece estar correto aqui. Digite yes no prompt de confirmação para prosseguir.

A execução do plano levará alguns minutos porque o Terraform espera até que a rede seja criada:

# ... Enter a value: yes google_compute_network.vpc_network: Creating... google_compute_network.vpc_network: Still creating... [10s elapsed] google_compute_network.vpc_network: Still creating... [20s elapsed] google_compute_network.vpc_network: Still creating... [30s elapsed] google_compute_network.vpc_network: Still creating... [40s elapsed] google_compute_network.vpc_network: Still creating... [50s elapsed] google_compute_network.vpc_network: Creation complete after 58s [id=terraform-network] Apply complete! Resources: 1 added, 0 changed, 0 destroyed.

Depois disso, o Terraform terá concluído tudo. Acesse o Console do Cloud para ver a rede provisionada.

3. No Console, no menu de navegação, acesse Rede VPC. Observe que a opção terraform-network foi provisionada.

4. No Cloud Shell, execute o comando terraform show para inspecionar o estado atual:

terraform show

Esses valores podem ser usados como referência para configurar outros recursos ou saídas, que serão abordados mais tarde neste laboratório.

Clique em Verificar meu progresso para ver o objetivo. Criação de recursos no Terraform

Tarefa 2. Alterar infraestrutura

Na seção anterior, você criou uma infraestrutura básica com o Terraform: uma rede VPC. Nesta seção, será necessário modificar sua configuração, e você verá como o Terraform lida com mudanças.

A infraestrutura está em constante evolução e o Terraform foi criado para ajudar a gerenciar e aplicar essa mudança. À medida que as configurações do Terraform são alteradas, ele cria um plano de execução que modifica apenas o que é necessário para chegar ao estado desejado.

Ao usar o Terraform para alterar a infraestrutura, você pode controlar as versões não apenas das suas configurações, mas também o estado, para entender como a infraestrutura evolui com o passar do tempo.

Adicionar recursos

Novos recursos podem ser adicionados ao incluí-los na configuração do Terraform e executar terraform apply para provisioná-los.

1. No Editor, adicione um recurso de instância do Compute a main.tf:

resource "google_compute_instance" "vm_instance" { name = "terraform-instance" machine_type = "e2-micro" boot_disk { initialize_params { image = "debian-cloud/debian-11" } } network_interface { network = google_compute_network.vpc_network.name access_config { } } }

Este recurso inclui mais alguns argumentos. O nome e o tipo de máquina são strings simples, mas boot_disk e network_interface são blocos mais complexos. Confira todas as opções disponíveis na documentação do google_compute_instance.

Para este exemplo, a instância do Compute vai usar um sistema operacional Debian e será conectada à rede VPC criada anteriormente. Observe como esta configuração faz referência à propriedade de nome da rede com google_compute_network.vpc_network.name -- google_compute_network.vpc_network é o ID, que corresponde aos valores no bloco que define a rede, e name é uma propriedade desse recurso.

A presença do bloco access_config, mesmo sem nenhum argumento, garante que a instância esteja acessível na Internet.

2. Agora, execute terraform apply para criar a instância do Compute:

terraform apply

3. De novo, responda yes ao prompt de confirmação.

Esta é uma mudança bem simples - você adicionou um recurso "google_compute_instance" chamado "vm_instance" à sua configuração e o Terraform criou o recurso no Google Cloud.

Como alterar recursos

O Terraform não serve só para criar, mas também para mudar recursos.

1. Adicione um argumento tags a "vm_instance" para que fique parecido com o seguinte:

resource "google_compute_instance" "vm_instance" { name = "terraform-instance" machine_type = "e2-micro" tags = ["web", "dev"] # ... }

2. Execute terraform apply de novo para atualizar a instância:

terraform apply

3. O prefixo ~ significa que o Terraform vai atualizar o recurso em vigor. Você pode aplicar essa alteração respondendo yes, e o Terraform vai adicionar as tags à instância.

Clique em Verificar meu progresso para ver o objetivo. Alterar infraestrutura

Alterações prejudiciais

Uma alteração prejudicial é aquela que exige que o provedor substitua o recurso existente em vez de atualizá-lo. Isso geralmente acontece porque o provedor em nuvem não oferece suporte à atualização do recurso da forma descrita pela configuração.

Alterar a imagem do disco da instância é um exemplo de uma alteração prejudicial.

1. Edite o bloco boot_disk no recurso vm_instance no arquivo de configuração e altere-o para o seguinte:

boot_disk { initialize_params { image = "cos-cloud/cos-stable" } }

2. Execute terraform apply outra vez para ver como o Terraform vai aplicar essa alteração aos recursos existentes:

terraform apply

O prefixo -/+ significa que o Terraform vai destruir e recriar o recurso em vez de atualizá-lo no local. Embora alguns atributos possam ser atualizados no local (que são mostrados com o prefixo ~), alterar a imagem do disco de inicialização para uma instância exige que ela seja recriada. O Terraform e o provedor Google Cloud tratam desses detalhes para você e o plano de execução deixa claro o que o Terraform vai fazer.

Além disso, o plano de execução mostra que a mudança da imagem do disco é o que exigiu que sua instância fosse substituída. Usando essa informação, é possível ajustar suas alterações para tentar evitar a destruição/criação de atualizações se elas não puderem ser aceitas em algumas situações.

3. Outra vez, o Terraform solicita a aprovação do plano de execução antes de continuar. Responda yes para executar as etapas planejadas.

Conforme indicado pelo plano de execução, o Terraform primeiro destruiu a instância existente e depois criou uma nova no lugar. Você pode usar terraform show novamente para conferir os novos valores associados a esta instância.

Destruir a infraestrutura

Agora você já sabe criar e mudar a infraestrutura. Antes de passar para a criação de vários recursos e mostrar as dependências deles, você vai ver como destruir completamente a infraestrutura gerenciada pelo Terraform.

Destruir a infraestrutura é um evento raro em ambientes de produção. No entanto, se você estiver usando o Terraform para ativar vários ambientes, como desenvolvimento, teste e preparo, destruir será sempre uma ação útil.

Os recursos podem ser destruídos usando o comando terraform destroy, que é semelhante a terraform apply, mas se comporta como se todos os recursos tivessem sido removidos da configuração.

• Experimente o comando terraform destroy. Responda yes para executar esse plano e destruir a infraestrutura:

terraform destroy

O prefixo - indica que a instância e a rede serão destruídas. Da mesma forma que com o apply, o Terraform mostra seu plano de execução e espera aprovação antes de fazer qualquer alteração.

Assim como com terraform apply, o Terraform determina a ordem em que as coisas devem ser destruídas. O Google Cloud não vai permitir que uma rede VPC seja excluída se ainda houver recursos nela. Por isso, o Terraform espera a destruição da instância antes de destruir a rede. Ao realizar operações, o Terraform cria um gráfico de dependência para determinar a ordem correta das operações. Em casos mais complicados com vários recursos, o Terraform vai realizar operações em paralelo quando for seguro fazer isso.

Clique em Verificar meu progresso para ver o objetivo. Alterações prejudiciais

Tarefa 3. Criar dependências de recursos

Nesta seção, você vai aprender mais sobre dependências de recursos e como usar os parâmetros deles para compartilhar informações sobre um recurso com outros.

A infraestrutura real tem um conjunto diferente de recursos e tipos de recursos. As configurações do Terraform podem ter vários recursos e tipos de recursos, e esses tipos podem abranger vários provedores.

Nesta seção, você verá um exemplo básico de como configurar vários recursos e como usar atributos de recursos para configurar outros.

• Recrie a rede e a instância. Os recursos serão criados depois que você responder yes ao prompt:

terraform apply

Como atribuir um endereço IP estático

1. Agora, adicione à sua configuração atribuindo um IP estático à instância da VM em main.tf:

resource "google_compute_address" "vm_static_ip" { name = "terraform-static-ip" }

A adição de um recurso de instância da VM deve parecer familiar com o exemplo anterior, exceto pelo fato de que dessa vez você está criando um tipo de recurso "google_compute_address", que aloca um endereço IP reservado para o projeto.

2. Em seguida, execute terraform plan:

terraform plan

Você pode ver o que será criado com terraform plan:

$ terraform plan Refreshing Terraform state in-memory prior to plan... The refreshed state will be used to calculate this plan, but will not be persisted to local or remote state storage. google_compute_network.vpc_network: Refreshing state... [id=terraform-network] google_compute_instance.vm_instance: Refreshing state... [id=terraform-instance] ------------------------------------------------------------------------ An execution plan has been generated and is shown below. Resource actions are indicated with the following symbols: + create Terraform will perform the following actions: # google_compute_address.vm_static_ip will be created + resource "google_compute_address" "vm_static_ip" { + address = (known after apply) + address_type = "EXTERNAL" + creation_timestamp = (known after apply) + id = (known after apply) + name = "terraform-static-ip" + network_tier = (known after apply) + project = (known after apply) + region = (known after apply) + self_link = (known after apply) + subnetwork = (known after apply) + users = (known after apply) } Plan: 1 to add, 0 to change, 0 to destroy. ------------------------------------------------------------------------ Observação: você não especificou um parâmetro "-out" para salvar este plano. Portanto, o Terraform não pode garantir que exatamente essas ações serão executadas se "terraform apply" for executado na sequência.

Diferente de terraform apply, o comando plan vai mostrar apenas o que seria alterado e nunca aplicar as alterações diretamente. Observe que a única alteração que você fez até agora foi adicionar um IP estático. Em seguida, é preciso anexar o endereço IP à instância.

3. Atualize a configuração network_interface para a instância da seguinte maneira:

network_interface { network = google_compute_network.vpc_network.self_link access_config { nat_ip = google_compute_address.vm_static_ip.address } }

O bloco access_config tem vários argumentos opcionais, e, neste caso, você definirá nat_ip como sendo o endereço IP estático. Quando o Terraform ler essa configuração, ele vai:

• Garantir que vm_static_ip seja criado antes de vm_instance
• Salvar as propriedades de vm_static_ip no estado
• Definir nat_ip como o valor da propriedade vm_static_ip.address

4. Execute terraform plan novamente, mas, desta vez, salve o plano:

terraform plan -out static_ip

Se salvar o plano dessa forma, você poderá aplicar exatamente o mesmo plano no futuro. Se você tentar aplicar o arquivo criado pelo plano, o Terraform primeiro verificará se será feito exatamente o mesmo conjunto de alterações antes de aplicar o plano.

Nesse caso, é possível ver que o Terraform criará um novo google_compute_address e atualizará a VM existente para usá-lo.

5. Execute terraform apply "static_ip" para ver como o Terraform planeja aplicar essa alteração:

terraform apply "static_ip"

Conforme mostrado acima, o Terraform criou o IP estático antes de modificar a instância da VM. O Terraform é capaz de inferir uma dependência devido à expressão de interpolação que passa do endereço IP para a configuração da interface de rede da instância. E sabe que isso deve criar o IP estático antes de atualizar a instância.

Clique em Verificar meu progresso para ver o objetivo. Criar dependências de recursos

Dependências implícitas e explícitas

Ao estudar os atributos de recursos usados nas expressões de interpolação, o Terraform pode inferir automaticamente quando um recurso depende de outro. No exemplo acima, a referência a google_compute_address.vm_static_ip.address cria uma dependência implícita no google_compute_address chamada vm_static_ip.

O Terraform usa essas informações de dependência para determinar a ordem correta na qual criar e atualizar recursos diferentes. No exemplo acima, o Terraform sabe qual vm_static_ip deve ser criado antes da vm_instance ser atualizada para usá-lo.

As dependências implícitas via expressões de interpolação são a maneira principal para informar ao Terraform sobre essas relações e devem ser usadas sempre que possível.

Às vezes, há dependências entre recursos que não são visíveis ao Terraform. O argumento depends_on pode ser adicionado a qualquer recurso e aceita uma lista de recursos para os quais criar dependências explícitas.

Por exemplo, talvez um aplicativo executado na sua instância queira usar um bucket do Cloud Storage específico, mas essa dependência será configurada no código do aplicativo e, assim, não ficará visível ao Terraform. Nesse caso, você pode usar depends_on para declarar explicitamente a dependência.

1. Adicione um bucket do Cloud Storage e uma instância com uma dependência explícita no bucket adicionando o seguinte a main.tf:

# Novo recurso para o bucket de armazenamento que o aplicativo vai usar. resource "google_storage_bucket" "example_bucket" { name = "<UNIQUE-BUCKET-NAME>" location = "US" website { main_page_suffix = "index.html" not_found_page = "404.html" } } # Cria uma nova instância que usa o bucket resource "google_compute_instance" "another_instance" { # Diz ao Terraform que a criação desta instância de VM só pode ocorrer depois que o # bucket de armazenamento tiver sido criado. depends_on = [google_storage_bucket.example_bucket] name = "terraform-instance-2" machine_type = "e2-micro" boot_disk { initialize_params { image = "cos-cloud/cos-stable" } } network_interface { network = google_compute_network.vpc_network.self_link access_config { } } } Observação: É necessário que os buckets de armazenamento sejam exclusivos globalmente. Por isso, você precisará substituir UNIQUE-BUCKET-NAME por um nome válido e exclusivo para um bucket. Usar seu nome e a data é uma boa maneira de criar um nome de bucket exclusivo.

Você pode supor para onde irão esses recursos na sua configuração. A ordem em que os recursos são definidos em um arquivo de configuração do Terraform não tem nenhum efeito sobre como o Terraform aplica as alterações. Organize os arquivos de configuração como fizer mais sentido para você e sua equipe.

2. Agora execute terraform plan e terraform apply para conferir essas alterações em ação:

terraform plan terraform apply

Clique em Verificar meu progresso para ver o objetivo. Criar uma instância dependente de um bucket

3. Antes de continuar, remova esses recursos novos da sua configuração e execute terraform apply outra vez para destruí-los. Você não usará mais o bucket ou a segunda instância neste laboratório.

Tarefa 4. Provisionar infraestrutura

A instância do Compute lançada nesse ponto é baseada na imagem determinada do Google, mas não há nenhum outro software instalado ou configuração aplicada.

O Google Cloud permite que os clientes gerenciem suas próprias imagens personalizadas do sistema operacional. Essa pode ser uma ótima maneira de garantir que as instâncias provisionadas com o Terraform sejam pré-configuradas com base nas suas necessidades. Packer é a ferramenta perfeita para isso e inclui um builder para o Google Cloud.

O Terraform usa provisionadores para fazer upload de arquivos, executar scripts de shell ou instalar e acionar outros softwares, como ferramentas de gerenciamento de configuração.

Como definir um provisionador

1. Para definir um provisionador, modifique o bloco de recursos definindo a primeira vm_instance na sua configuração para que seja parecida com o seguinte:

resource "google_compute_instance" "vm_instance" { name = "terraform-instance" machine_type = "e2-micro" tags = ["web", "dev"] provisioner "local-exec" { command = "echo ${google_compute_instance.vm_instance.name}: ${google_compute_instance.vm_instance.network_interface[0].access_config[0].nat_ip} >> ip_address.txt" } # ... }

Isso adiciona um bloco provisioner ao bloco resource. Vários blocos provisioner podem ser adicionados para definir várias etapas de provisionamento. O Terraform suporta muitos provisionadores, mas para este exemplo você está usando o provisionador local-exec.

O provisionador local-exec executa um comando localmente na máquina que está executando o Terraform, não na instância de VM em si. Você está usando este provisionador em relação a outros. Portanto, não precisamos nos preocupar sobre como especificar informações de conexão agora.

Isso também mostra um exemplo mais complexo de interpolação de string do que visto antes. Cada instância de VM pode ter várias interfaces de rede. Por isso, faça referência à primeira com network_interface[0], com a contagem começando do 0, como feito pela maioria das linguagens de programação. Cada interface de rede pode ter vários blocos access_config também, portanto, especifique novamente o primeiro.

2. Execute terraform apply:

terraform apply

Neste ponto, a saída pode parecer confusa de início.

O Terraform não encontrou nada para fazer - e, se você conferir, vai notar que não há nenhum arquivo ip_address.txt na sua máquina local.

O Terraform trata os provisionadores de forma diferente de outros argumentos. Os provisionadores só são executados quando um recurso é criado, mas a adição de um provisionador não faz obrigatoriamente com que esse recurso seja destruído e recriado.

3. Use terraform taint para dizer ao Terraform para recriar a instância:

terraform taint google_compute_instance.vm_instance

Um recurso com taint será destruído e recriado durante o próximo apply.

4. Execute terraform apply agora:

terraform apply

5. Verifique se tudo funcionou vendo o conteúdo do arquivo ip_address.txt.

Ele contém o endereço IP, como você perguntou.

Provisionadores com falha e recursos com taint

Se um recurso for criado, mas falhar na etapa de provisionamento, o Terraform terá um erro e vai marcar o recurso como tainted. Um recurso desse tipo não deixa de existir, embora não seja considerado seguro para uso, uma vez que o provisionamento falhou.

Quando você gerar seu próximo plano de execução, o Terraform vai remover todos os recursos com taint e criar novos recursos, tentando provisioná-los novamente após a criação.

Destruir provisionadores

Os provisionadores também podem ser definidos para execução apenas durante a operação de destruição. Eles são úteis para a execução de limpeza do sistema, extração de dados, etc.

Para muitos recursos, usar mecanismos de limpeza integrados é recomendado quando possível (como scripts init), mas os provisionadores podem ser usados se for necessário.

Este laboratório não vai exibir nenhum exemplo de provisionador de destruição. Se for necessário usar provisionadores de destruição, consulte a documentação do provisionador.

Parabéns!

Neste laboratório, você aprendeu a criar, alterar e destruir infraestruturas com o Terraform. Você criou dependências de recursos e provisionou uma infraestrutura básica com os arquivos de configuração do Terraform.

Próximas etapas/Saiba mais

Confira os recursos a seguir para acessar outros materiais práticos do Terraform:

• Hashicorp no Google Cloud Marketplace.
• Hashicorp Learn
• Comunidade do Terraform
• Exemplos do Terraform no Google

Treinamento e certificação do Google Cloud

Esses treinamentos ajudam você a aproveitar as tecnologias do Google Cloud ao máximo. Nossas aulas incluem habilidades técnicas e práticas recomendadas para ajudar você a alcançar rapidamente o nível esperado e continuar sua jornada de aprendizado. Oferecemos treinamentos que vão do nível básico ao avançado, com opções de aulas virtuais, sob demanda e por meio de transmissões ao vivo para que você possa encaixá-las na correria do seu dia a dia. As certificações validam sua experiência e comprovam suas habilidades com as tecnologias do Google Cloud.

Manual atualizado em 26 de janeiro de 2024

Laboratório testado em 25 de setembro de 2023

Copyright 2024 Google LLC. Todos os direitos reservados. Google e o logotipo do Google são marcas registradas da Google LLC. Todos os outros nomes de produtos e empresas podem ser marcas registradas das respectivas empresas a que estão associados.