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

GSP751

Visão geral

Quando você gerencia sua infraestrutura com o Terraform, configurações cada vez mais complexas são criadas. Não há limite intrínseco para a complexidade de um único arquivo ou diretório de configuração do Terraform. Portanto, é possível continuar gravando e atualizando seus arquivos de configuração em um único diretório. Porém, se você faz isso, pode se deparar com um ou mais dos seguintes problemas:

• Entender e navegar pelos arquivos de configuração vai ficar cada vez mais difícil.
• Atualizar a configuração vai ser mais arriscado, porque a atualização de um bloco pode causar consequências não intencionais nos outros blocos da sua configuração.
• Por exemplo, a duplicação de blocos de configuração semelhantes pode aumentar quando você configurar ambientes separados de desenvolvimento/preparo/produção, o que vai causar uma carga crescente ao atualizar essas partes da sua configuração.
• Se quiser compartilhar partes da sua configuração entre projetos e equipes, pode ser difícil recortar e colar blocos de configuração entre projetos, aumentando a chance de erros.

Neste laboratório, vamos aprender como os módulos podem resolver esses problemas, a estrutura de um módulo do Terraform e as práticas recomendadas ao usar e criar módulos.

Para que servem os módulos?

Os módulos podem ajudar a resolver os problemas listados acima de algumas formas, por exemplo:

• Organizar configuração: os módulos facilitam a navegação, o entendimento e a atualização da configuração, mantendo juntas as partes da configuração relacionadas. Mesmo infraestruturas moderadamente complexas podem exigir centenas ou milhares de linhas de configuração para serem implementadas. Com os módulos, você pode organizar sua configuração em componentes lógicos.

• Encapsular configuração: outro benefício de usar módulos é encapsular a configuração em componentes lógicos distintos. O encapsulamento pode ajudar a evitar consequências não intencionais, como uma alteração em uma parte de sua configuração causando acidentalmente alterações em outra infraestrutura, e a reduzir as chances de erros simples, como usar o mesmo nome para dois recursos diferentes.

• Reutilizar configuração: escrever toda sua configuração sem usar códigos existentes pode ser demorado e propenso a erros. Com o uso de módulos, é possível poupar tempo e reduzir erros caros ao reutilizar uma configuração escrita por você, por outros membros da sua equipe ou por profissionais do Terraform que tenham publicado módulos para uso. Você também pode compartilhar módulos que tiver criado com sua equipe ou com o público em geral, para que possam aproveitar seu trabalho.

• Fornecer consistência e garantir as práticas recomendadas: os módulos também ajudam a fornecer consistência nas suas configurações. A consistência facilita o entendimento de configurações complexas e ajuda a garantir que as práticas recomendadas sejam aplicadas em toda sua configuração. Por exemplo, os provedores de nuvem oferecem muitas opções para configurar serviços de armazenamento de objetos, como Amazon S3 (Simple Storage Service) ou buckets do Cloud Storage do Google. Muitos incidentes graves de segurança envolvem o armazenamento de objetos com proteção incorreta e, devido à quantidade de opções de configuração complexas envolvidas, é comum configurar esses serviços de maneira incorreta por acidente.

Usar módulos pode ajudar a reduzir esses erros. Por exemplo, você pode criar um módulo para descrever como todos os buckets de sites públicos da sua organização são configurados, e outro módulo para buckets privados usados para aplicativos de geração de registros. Além disso, se uma configuração para um tipo de recurso precisar ser atualizada, o uso de módulos possibilita que você faça essa atualização em apenas um local e depois a aplique a todos os casos em que o módulo seja usado.

Objetivos

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

• Usar um módulo do Registry
• Criar um módulo

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.

O que é um módulo do Terraform?

Um módulo do Terraform é um conjunto de arquivos de configuração do Terraform em um único diretório. Mesmo uma configuração simples, que consiste em um único diretório com um ou mais arquivos .tf, corresponde a um módulo. Quando você executa comandos do Terraform diretamente de um diretório desses, ele é considerado o módulo raiz. Nesse sentido, toda configuração do Terraform é parte de um módulo. É possível ter um conjunto simples de arquivos de configuração do Terraform, como esse:

├── LICENSE ├── README.md ├── main.tf ├── variables.tf ├── outputs.tf

Nesse caso, quando você executa comandos do Terraform de dentro do diretório minimal-module, o conteúdo dele é considerado o módulo raiz.

Como chamar módulos

Os comandos do Terraform só usam diretamente os arquivos de configuração em um diretório, que geralmente é o diretório de trabalho atual. No entanto, sua configuração pode usar blocos de módulo para chamar módulos em outros diretórios. Quando o Terraform encontra um bloco de módulo, ele carrega e processa os arquivos de configuração daquele módulo.

Um módulo que é chamado por outra configuração às vezes é chamado de "módulo filho" dessa configuração.

Módulos locais e remotos

Os módulos podem ser carregados do sistema de arquivos local ou de uma fonte remota. O Terraform oferece suporte a diversas fontes remotas, incluindo o Terraform Registry, a maioria dos sistemas de controle de versões, URLs HTTP e registros de módulo privado do Terraform Cloud ou do Terraform Enterprise.

Melhores práticas dos módulos

De muitas maneiras, os módulos do Terraform se assemelham aos conceitos de bibliotecas, pacotes ou módulos presentes na maioria das linguagens de programação e oferecem muitos benefícios semelhantes. Assim como quase qualquer programa de computador não trivial, as configurações reais do Terraform geralmente precisam usar módulos para fornecer os benefícios mencionados acima.

Recomenda-se que todos os usuários do Terraform usem módulos seguindo estas práticas recomendadas:

• Crie sua configuração com um plano para os módulos. Mesmo para configurações levemente complexas do Terraform gerenciadas por apenas uma pessoa, os benefícios do uso de módulos compensam o tempo necessário para usá-los corretamente.

• Use módulos locais para organizar e encapsular seu código. Mesmo que você não esteja usando ou publicando módulos remotos, organizar sua configuração em termos de módulos desde o início vai reduzir significativamente o trabalho de manutenção e atualização da sua configuração à medida que sua infraestrutura ficar mais complexa.

• Encontre módulos úteis no Terraform Registry público. Assim é possível implementar sua configuração com rapidez e confiança, contando com o trabalho de outras pessoas.

• Publique e compartilhe módulos com sua equipe. A maior parte das infraestruturas é gerenciada por uma equipe de pessoas, e os módulos são uma ferramenta importante que as equipes podem usar para criar e manter infraestruturas. Como já mencionado, você pode publicar módulos de maneira pública ou privada. Vamos examinar como fazer isso em um laboratório mais adiante.

Tarefa 1. Usar módulos do Registry

Nesta seção, vamos usar módulos do Terraform Registry para provisionar um ambiente de exemplo no Google Cloud. Os conceitos usados aqui podem ser aplicados a qualquer módulo, de qualquer fonte.

• Abra a página do Terraform Registry do módulo Terraform Network em uma nova guia ou janela do navegador. A aparência da página vai ser a seguinte:

A página inclui informações sobre o módulo e um link para o repositório de origem. O lado direito da página inclui uma interface suspensa para selecionar a versão do módulo e instruções de uso do módulo a fim de provisionar a infraestrutura.

Quando você chama um módulo, o argumento source é exigido. Neste exemplo, o Terraform procura um módulo no Terraform Registry que corresponda à string fornecida. Também é possível usar um URL ou caminho de arquivo local para a origem dos seus módulos. Confira a documentação do Terraform para uma lista de possíveis fontes de módulo.

O outro argumento mostrado aqui é version. Para fontes com suporte, o argumento version permite que você defina quais versões do módulo serão carregadas. Neste laboratório, você vai especificar um número exato de versão para os módulos que usar. Descubra mais maneiras de especificar versões na documentação do módulo.

Outros argumentos para blocos de módulos são tratados como variáveis de entrada para os módulos.

Criar uma configuração do Terraform

1. Para começar, execute os comandos a seguir no Cloud Shell para clonar o projeto de exemplo simples do repositório GitHub dos módulos do Google Terraform e mudar para a ramificação v6.0.1.

git clone https://github.com/terraform-google-modules/terraform-google-network cd terraform-google-network git checkout tags/v6.0.1 -b v6.0.1

Isso garante que você use o número de versão correto.

2. Na barra de ferramentas do Cloud Shell, clique em Abrir editor. Para alternar o Cloud Shell e o editor de código, clique em Abrir editor ou Abrir terminal conforme necessário ou em Abrir em uma nova janela para deixar o Editor aberto em uma guia separada.

3. No editor, navegue até terraform-google-network/examples/simple_project, e abra o arquivo main.tf. Sua configuração do main.tf vai ficar assim:

module "test-vpc-module" { source = "terraform-google-modules/network/google" version = "~> 6.0" project_id = var.project_id # Replace this with your project ID network_name = "my-custom-mode-network" mtu = 1460 subnets = [ { subnet_name = "subnet-01" subnet_ip = "10.10.10.0/24" subnet_region = "us-west1" }, { subnet_name = "subnet-02" subnet_ip = "10.10.20.0/24" subnet_region = "us-west1" subnet_private_access = "true" subnet_flow_logs = "true" }, { subnet_name = "subnet-03" subnet_ip = "10.10.30.0/24" subnet_region = "us-west1" subnet_flow_logs = "true" subnet_flow_logs_interval = "INTERVAL_10_MIN" subnet_flow_logs_sampling = 0.7 subnet_flow_logs_metadata = "INCLUDE_ALL_METADATA" subnet_flow_logs_filter = "false" } ] }

Essa configuração inclui um bloco importante:

• module "test-vpc-module" define uma nuvem privada virtual (VPC) que vai fornecer serviços de rede para o restante da sua infraestrutura.

Configurar valores para as variáveis de entrada do módulo

Algumas variáveis de entrada são exigidas, ou seja, o módulo não fornece um valor padrão. Um valor explícito deve ser fornecido para que o Terraform seja executado corretamente.

• No bloco "test-vpc-module" do módulo, revise as variáveis de entrada que está configurando. Cada uma dessas variáveis de entrada está documentada no Terraform Registry. As entradas necessárias para este módulo são:

  • network_name: nome da rede que está sendo criada
  • project_id: ID do projeto em que essa VPC vai ser criada
  • subnets: lista de sub-redes que está sendo criada

Você vai precisar passar as variáveis de entrada para a configuração do módulo para usar a maioria dos módulos. A configuração que chama um módulo é responsável por definir seus valores de entrada, que são passados como argumentos para o bloco do módulo. Além de source e version, a maioria dos argumentos de um bloco de módulo define valores de variáveis.

Na página do Terraform Registry para o módulo de rede do Google Cloud, uma guia "Entradas" descreve todas as variáveis de entrada que têm suporte do módulo.

Definir variáveis de entrada raiz

Usar variáveis de entrada com módulos é muito semelhante a usar variáveis em qualquer configuração do Terraform. Um padrão comum é identificar quais variáveis de entrada do módulo você pode vir a alterar no futuro e, em seguida, criar variáveis correspondentes no arquivo variables.tf da sua configuração com valores padrão sensíveis. Essas variáveis podem então ser transmitidas para o bloco do módulo como argumentos.

1. Para recuperar sua Id do projeto, execute o seguinte comando no Cloud Shell:

gcloud config list --format 'value(core.project)'

2. No Editor, ainda no mesmo diretório, navegue até variables.tf.

3. Preencha a variável project_id com a saída do comando anterior. Você precisa respeitar o formato seguinte e configurar o valor default para a variável:

variable "project_id" { description = "The project ID to host the network in" default = "FILL IN YOUR PROJECT ID HERE" }

4. Em variables.tf, adicione a variável network_name. É possível usar o nome example-vpc ou qualquer outro que você quiser. Você precisa respeitar o formato seguinte e configurar o valor default para a variável:

variable "network_name" { description = "The name of the VPC network being created" default = "example-vpc" }

5. No arquivo main.tf, atualize o parâmetro network_name para usar a variável que você acabou de definir. Para isso, configure o valor como var.network_name.

module "test-vpc-module" { ... project_id = var.project_id network_name = var.network_name ...

6. No arquivo main.tf, atualize as regiões da sub-rede nas linhas 35, 40 e 47 de us-west1 para . Isso garante que as sub-redes serão criadas na região permitida do projeto. O módulo deve se parecer com isso:

subnets = [ { subnet_name = "subnet-01" subnet_ip = "10.10.10.0/24" subnet_region = "{{{project_0.default_region | REGION}}}" }, { subnet_name = "subnet-02" subnet_ip = "10.10.20.0/24" subnet_region = "{{{project_0.default_region | REGION}}}" subnet_private_access = "true" subnet_flow_logs = "true" }, { subnet_name = "subnet-03" subnet_ip = "10.10.30.0/24" subnet_region = "{{{project_0.default_region | REGION}}}" ... .. }

Definir valores de saída raiz

Módulos também têm valores de saída, que são definidos dentro do módulo, com a palavra-chave output. Você pode acessá-los referindo-se a module.<MODULE NAME>.<OUTPUT NAME>. Assim como as variáveis de entrada, as saídas de módulo são listadas na guia outputs no Terraform Registry.

As saídas do módulo geralmente são passadas para outras partes da sua configuração ou definidas como saídas no seu módulo raiz. Vamos examinar os dois usos neste laboratório.

• Navegue até o arquivo outputs.tf dentro do seu diretório de configurações. Verifique se o arquivo contém o seguinte:

output "network_name" { value = module.test-vpc-module.network_name description = "The name of the VPC being created" } output "network_self_link" { value = module.test-vpc-module.network_self_link description = "The URI of the VPC being created" } output "project_id" { value = module.test-vpc-module.project_id description = "VPC project id" } output "subnets_names" { value = module.test-vpc-module.subnets_names description = "The names of the subnets being created" } output "subnets_ips" { value = module.test-vpc-module.subnets_ips description = "The IP and cidrs of the subnets being created" } output "subnets_regions" { value = module.test-vpc-module.subnets_regions description = "The region where subnets will be created" } output "subnets_private_access" { value = module.test-vpc-module.subnets_private_access description = "Whether the subnets will have access to Google API's without a public IP" } output "subnets_flow_logs" { value = module.test-vpc-module.subnets_flow_logs description = "Whether the subnets will have VPC flow logs enabled" } output "subnets_secondary_ranges" { value = module.test-vpc-module.subnets_secondary_ranges description = "The secondary ranges associated with these subnets" } output "route_names" { value = module.test-vpc-module.route_names description = "The routes associated with this VPC" }

Provisionar infraestrutura

1. No Cloud Shell, navegue até seu diretório simple_project:

cd ~/terraform-google-network/examples/simple_project

2. Inicialize sua configuração do Terraform:

terraform init

3. Crie sua VPC:

terraform apply

4. Para aplicar as alterações e prosseguir, responda sim ao prompt.

Ótimo. Você acabou de usar seu primeiro módulo. A saída da sua configuração deve ter a seguinte aparência:

Outputs: network_name = "example-vpc" network_self_link = "https://www.googleapis.com/compute/v1/projects/qwiklabs-gcp-01-a68489b0625b/global/networks/example-vpc" project_id = "" route_names = [] subnets_flow_logs = [ false, true, true, ] subnets_ips = [ "10.10.10.0/24", "10.10.20.0/24", "10.10.30.0/24", ] subnets_names = [ "subnet-01", "subnet-02", "subnet-03", ] .... ....

Entender como os módulos funcionam

Ao usar um novo módulo pela primeira vez, você precisa executar o terraform init ou o terraform get para instalá-lo. Quando um desses comandos é executado, o Terraform instala todos os novos módulos no diretório .terraform/modules dentro do diretório de trabalho da sua configuração. Para módulos locais, o Terraform cria um link simbólico para o diretório do módulo. Por isso, todas as alterações dos módulos locais entram em vigor imediatamente, sem que você precise executar o terraform get novamente.

Limpar sua infraestrutura

Aprendemos como usar módulos do Terraform Registry, como configurar esses módulos com variáveis de entrada e como extrair valores de saída desses módulos.

1. Destrua a infraestrutura que você criou:

terraform destroy

2. Responda sim ao prompt. O Terraform vai destruir a infraestrutura que você criou.

3. Após ter destruído os recursos, exclua a pasta terraform-google-network.

cd ~ rm -rd terraform-google-network -f

Clique em Verificar meu progresso para conferir o objetivo. Provisionar infraestrutura.

Tarefa 2. Criar um módulo

Na última tarefa, você usou um módulo do Terraform Registry para criar uma rede VPC no Google Cloud. Embora o uso correto dos módulos existentes do Terraform seja uma habilidade importante, o aprendizado de como criar módulos também pode beneficiar qualquer usuário do Terraform. Recomendamos que você crie todas as configurações do Terraform supondo que elas possam ser usadas como um módulo, porque isso ajuda a projetar suas configurações para que sejam flexíveis, reutilizáveis e combináveis.

Como você já deve saber, o Terraform trata toda configuração como um módulo. Quando você executa comandos terraform ou usa o Terraform Cloud ou o Terraform Enterprise para acessar remotamente o Terraform, o diretório de destino que contém a configuração dele é tratado como o módulo raiz.

Nessa tarefa, você cria um módulo para gerenciar os buckets do Compute Storage usados para hospedar sites estáticos.

Estrutura do módulo

O Terraform trata qualquer diretório local referenciado no argumento source de um bloco de module como um módulo. Uma estrutura de arquivo comum para um novo módulo é:

├── LICENSE ├── README.md ├── main.tf ├── variables.tf ├── outputs.tf Observação: nenhum desses arquivos é necessário ou tem algum significado especial para o Terraform quando ele usa seu módulo. É possível criar um módulo com um único arquivo .tf ou usar qualquer outra estrutura de arquivos que quiser.

Cada um desses arquivos serve a um propósito:

• LICENSE contém a licença sob a qual seu módulo será distribuído. Quando você compartilha seu módulo, o arquivo LICENÇA permite que as pessoas que o utilizam entendam os termos sob os quais ele foi disponibilizado. O Terraform não usa esse arquivo.
• README.md contém documentação em formato markdown que descreve como usar o módulo. O Terraform não usa esse arquivo, mas serviços como o Terraform Registry e o GitHub exibem o conteúdo desse arquivo para os visitantes do Terraform Registry ou da página do GitHub do seu módulo.
• main.tf contém o conjunto principal de configurações do seu módulo. Também é possível criar outros arquivos de configuração e organizá-los de modo a fazerem sentido no seu projeto.
• variables.tf contém as definições de variáveis do seu módulo. Quando seu módulo é usado por outras pessoas, as variáveis são configuradas como argumentos no bloco do módulo. Como todos os valores do Terraform devem ser definidos, as variáveis que não têm um valor padrão se tornarão argumentos obrigatórios. Uma variável com um valor padrão também pode ser fornecida como um argumento de módulo, sobrepondo assim o valor padrão.
• outputs.tf contém as definições de saída do seu módulo. As saídas do módulo são disponibilizadas à configuração usando o módulo e, portanto, são frequentemente usadas para transmitir informações sobre as partes da sua infraestrutura definidas pelo módulo para outras partes da sua configuração.

Tenha cuidado com esses arquivos e não os distribua como parte do seu módulo:

• os arquivos terraform.tfstate e terraform.tfstate.backup contêm seu estado do Terraform e são a forma como o Terraform acompanha o relacionamento entre sua configuração e a infraestrutura por ela provisionada.
• O diretório .terraform contém os módulos e plug-ins usados para provisionar sua infraestrutura. Esses arquivos são específicos de uma instância individual do Terraform no provisionamento da infraestrutura, e não a configuração da infraestrutura definida nos arquivos .tf.
• Os arquivos *.tfvars não precisam ser distribuídos com seu módulo a menos que você também o esteja usando como uma configuração independente do Terraform, porque as variáveis de entrada do módulo são definidas por meio de argumentos para o bloco do módulo na sua configuração.

Observação: se você está rastreando alterações no seu módulo em um sistema de controle de versões como o Git, é melhor configurar seu sistema de controle de versões para ignorar esses arquivos. Veja um exemplo neste arquivo .gitignore do GitHub.

Criar um módulo

Navegue até seu diretório inicial e crie seu módulo raiz construindo um novo arquivo de configuração main.tf. Depois crie um diretório chamado modules que contém outra pasta chamada gcs-static-website-bucket. Você vai trabalhar com três arquivos de configuração do Terraform no diretório gcs-static-website-bucket: website.tf, variables.tf e outputs.tf.

1. Criar o diretório para seu novo módulo:

cd ~ touch main.tf mkdir -p modules/gcs-static-website-bucket

2. Navegue até o diretório do módulo e execute os seguintes comandos para criar três arquivos vazios:

cd modules/gcs-static-website-bucket touch website.tf variables.tf outputs.tf

3. No diretório gcs-static-website-bucket, execute o comando a seguir para criar um arquivo chamado README.md com o seguinte conteúdo:

tee -a README.md <<EOF # GCS static website bucket Este módulo provisiona buckets do Cloud Storage configurados para hospedagem de sites estáticos. EOF Observação: escolher a licença correta para seus módulos está fora do escopo deste laboratório Neste laboratório, vamos usar a licença de código aberto Apache 2.0.

4. Crie outro arquivo chamado LICENSE com o seguinte conteúdo:

tee -a LICENSE <<EOF Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0 Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License. EOF Observação: nenhum desses arquivos é exigido ou usado pelo Terraform Ter os arquivos é uma prática recomendada para módulos que podem ser compartilhados com outras pessoas.

Sua estrutura de diretórios do módulo atual deve estar assim:

main.tf modules/ └── gcs-static-website-bucket ├── LICENSE ├── README.md ├── website.tf ├── outputs.tf └── variables.tf

5. Adicione este recurso de bucket do Cloud Storage ao seu arquivo website.tf dentro do diretório modules/gcs-static-website-bucket:

resource "google_storage_bucket" "bucket" { name = var.name project = var.project_id location = var.location storage_class = var.storage_class labels = var.labels force_destroy = var.force_destroy uniform_bucket_level_access = true versioning { enabled = var.versioning } dynamic "retention_policy" { for_each = var.retention_policy == null ? [] : [var.retention_policy] content { is_locked = var.retention_policy.is_locked retention_period = var.retention_policy.retention_period } } dynamic "encryption" { for_each = var.encryption == null ? [] : [var.encryption] content { default_kms_key_name = var.encryption.default_kms_key_name } } dynamic "lifecycle_rule" { for_each = var.lifecycle_rules content { action { type = lifecycle_rule.value.action.type storage_class = lookup(lifecycle_rule.value.action, "storage_class", null) } condition { age = lookup(lifecycle_rule.value.condition, "age", null) created_before = lookup(lifecycle_rule.value.condition, "created_before", null) with_state = lookup(lifecycle_rule.value.condition, "with_state", null) matches_storage_class = lookup(lifecycle_rule.value.condition, "matches_storage_class", null) num_newer_versions = lookup(lifecycle_rule.value.condition, "num_newer_versions", null) } } } }

A documentação do provedor é GitHub.

6. Navegue até o arquivo variables.tf do seu módulo e adicione o seguinte código:

variable "name" { description = "The name of the bucket." type = string } variable "project_id" { description = "The ID of the project to create the bucket in." type = string } variable "location" { description = "The location of the bucket." type = string } variable "storage_class" { description = "The Storage Class of the new bucket." type = string default = null } variable "labels" { description = "A set of key/value label pairs to assign to the bucket." type = map(string) default = null } variable "bucket_policy_only" { description = "Enables Bucket Policy Only access to a bucket." type = bool default = true } variable "versioning" { description = "While set to true, versioning is fully enabled for this bucket." type = bool default = true } variable "force_destroy" { description = "When deleting a bucket, this boolean option will delete all contained objects. If false, Terraform will fail to delete buckets which contain objects." type = bool default = true } variable "iam_members" { description = "The list of IAM members to grant permissions on the bucket." type = list(object({ role = string member = string })) default = [] } variable "retention_policy" { description = "Configuration of the bucket's data retention policy for how long objects in the bucket should be retained." type = object({ is_locked = bool retention_period = number }) default = null } variable "encryption" { description = "A Cloud KMS key that will be used to encrypt objects inserted into this bucket" type = object({ default_kms_key_name = string }) default = null } variable "lifecycle_rules" { description = "The bucket's Lifecycle Rules configuration." type = list(object({ # Object with keys: # - type - The type of the action of this Lifecycle Rule. Supported values: Delete and SetStorageClass. # - storage_class - (Required if action type is SetStorageClass) The target Storage Class of objects affected by this Lifecycle Rule. action = any # Object with keys: # - age - (Optional) Minimum age of an object in days to satisfy this condition. # - created_before - (Optional) Creation date of an object in RFC 3339 (e.g. 2017-06-13) to satisfy this condition. # - with_state - (Optional) Match to live and/or archived objects. Supported values include: "LIVE", "ARCHIVED", "ANY". # - matches_storage_class - (Optional) Storage Class of objects to satisfy this condition. Supported values include: MULTI_REGIONAL, REGIONAL, NEARLINE, COLDLINE, STANDARD, DURABLE_REDUCED_AVAILABILITY. # - num_newer_versions - (Optional) Relevant only for versioned objects. The number of newer versions of an object to satisfy this condition. condition = any })) default = [] }

7. Adicione uma saída ao seu módulo, no arquivo outputs.tf que fica dentro dele:

output "bucket" { description = "The created storage bucket" value = google_storage_bucket.bucket }

Assim como as variáveis, as saídas nos módulos executam a mesma função que no módulo raiz, mas são acessadas de modo diferente. As saídas de um módulo podem ser acessadas como atributos somente leitura nos objetos do módulo, disponibilizado na configuração que o chama.

8. Volte a main.tf no seu diretório raiz e adicione uma referência ao novo módulo:

module "gcs-static-website-bucket" { source = "./modules/gcs-static-website-bucket" name = var.name project_id = var.project_id location = "{{{project_0.default_region | REGION}}}" lifecycle_rules = [{ action = { type = "Delete" } condition = { age = 365 with_state = "ANY" } }] }

9. Em root directory, crie um arquivo outputs.tf para seu módulo raiz.

cd ~ touch outputs.tf

10. Adicione o seguinte código ao arquivo outputs.tf:

output "bucket-name" { description = "Bucket names." value = "module.gcs-static-website-bucket.bucket" }

11. Em root directory, crie um arquivo variables.tf:

touch variables.tf

12. Adicione o código a seguir no arquivo variables.tf. Defina as variáveis project_id e name como o padrão para o ID do projeto: .

variable "project_id" { description = "The ID of the project in which to provision resources." type = string default = "FILL IN YOUR PROJECT ID HERE" } variable "name" { description = "Name of the buckets to create." type = string default = "FILL IN A (UNIQUE) BUCKET NAME HERE" } Observação: o nome do seu bucket de armazenamento precisa ser globalmente exclusivo. Usar seu nome e a data atual é uma boa forma de criar um nome de bucket exclusivo. Você também pode usar a ID do projeto.

Instalar o módulo local

Sempre que você adiciona um novo módulo para uma configuração, o Terraform precisa instalar o módulo antes que ele possa ser usado. Tanto o comando terraform get quanto o comando terraform init instalam e atualizam os módulos. O comando terraform init também inicializa back-ends e instala plug-ins.

1. Instale o módulo:

terraform init

2. Provisione seu bucket:

terraform apply

3. Responda sim ao prompt. Seu bucket e outros recursos são provisionados.

Fazer upload de arquivos para o bucket

Você configurou e usou seu próprio módulo para criar um site estático. Não esqueça de acessá-lo. No momento não há nada dentro do seu bucket, por isso não aparece nada no site. Para poder ver conteúdos, você precisa fazer upload de objetos no seu bucket. Você pode fazer upload do conteúdo do diretório www no repositório do GitHub.

1. Faça download do conteúdo de amostra para seu diretório inicial:

cd ~ curl https://raw.githubusercontent.com/hashicorp/learn-terraform-modules/master/modules/aws-s3-static-website-bucket/www/index.html > index.html curl https://raw.githubusercontent.com/hashicorp/learn-terraform-modules/blob/master/modules/aws-s3-static-website-bucket/www/error.html > error.html

2. Copie os arquivos para o bucket, substituindo YOUR-BUCKET-NAME pelo nome do seu bucket de armazenamento:

gsutil cp *.html gs://YOUR-BUCKET-NAME

3. Em uma nova guia do navegador, acesse o site https://storage.cloud.google.com/YOUR-BUCKET-NAME/index.html, substituindo YOUR-BUCKET-NAME pelo nome do seu bucket de armazenamento.

Uma página da Web em HTML básico vai aparecer com o texto Nothing to see here.

Clique em Verificar meu progresso para conferir o objetivo. Crie um módulo.

Limpar o site e a infraestrutura

Por fim, limpe seu projeto, destruindo a infraestrutura que acabou de criar.

1. Destrua seus recursos do Terraform:

terraform destroy

Depois de responder sim ao prompt, o Terraform vai destruir todos os recursos que você criou seguindo este laboratório.

Parabéns!

Neste laboratório, você aprendeu os fundamentos dos módulos do Terraform e como usar um módulo pré-existente do Registry. Depois você elaborou seu próprio módulo para criar um site estático hospedado em um bucket do Cloud Storage. Ao fazer isso, você definiu entradas, saídas e variáveis para seus arquivos de configuração e aprendeu as práticas recomendadas para a criação de módulos.

Próximas etapas / Saiba mais

Os links abaixo oferecem oportunidades de praticar com o 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 11 de dezembro 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.