Observação:

Introdução ao Terraform no Oracle Cloud Infrastructure

Introdução

O Terraform é uma ferramenta de Infraestrutura como Código (IaC) desenvolvida pela Hashicorp que permite definir, provisionar e gerenciar sua infraestrutura em vários provedores de nuvem usando a sintaxe da linguagem Terraform, HCL. O Terraform permite automatizar todo o ciclo de vida da sua infraestrutura de nuvem, facilitando a criação, a atualização e a escala de recursos de maneira consistente e reproduzível. O Terraform é amplamente usado pelas equipes do DevOps para gerenciar recursos de nuvem, melhorar a eficiência da infraestrutura, reduzir erros manuais e recursos de nuvem de controle de versão.

Este tutorial ajuda você a iniciar sua jornada para aproveitar o IaC para implantar e gerenciar sua infraestrutura de nuvem.

Workflow de Arquitetura do Terraform

Workflow de Arquitetura do Terraform

Objetivos

Pré-requisitos

Tarefa 1: Declarar o Provedor

Um provedor Terraform refere-se a um plug-in que é responsável por entender e interagir com um tipo específico de infraestrutura ou serviço. Os provedores são a ponte entre o Terraform e as APIs dos serviços ou plataformas que você deseja gerenciar. Os provedores permitem que o Terraform se comunique e interaja com plataformas de nuvem de forma eficaz. Em outras palavras, o provedor Terraform é como um tradutor que ajuda o Terraform a conversar com diferentes serviços ou sistemas de nuvem, permitindo que ele crie, gerencie e exclua recursos como máquinas virtuais, bancos de dados e redes.

Cada provedor normalmente corresponde a uma plataforma de nuvem específica (por exemplo, OCI, AWS, Azure, GCP) ou serviço de infraestrutura (por exemplo, Kubernetes, Docker).

  1. Crie uma pasta chamada terraform-beginners-demo e abra-a no VS Code.

  2. Instale a extensão HashiCorp Terraform no VS Code.

  3. Crie os arquivos provider.tf e variables.tf na pasta terraform-beginners-demo.

  4. Copie o código a seguir no arquivo provider.tf.

    terraform {
  required_providers {
    oci = {
      source = "oracle/oci"
      version = "5.30.0"
    }
  }
}

provider "oci" {
  tenancy_ocid          = var.tenancy_id
  user_ocid             = var.user_id
  fingerprint           = var.api_fingerprint
  private_key_path      = var.api_private_key_path
  region                = var.region
}

    Observação: Usamos o código da página oficial Registro do Terraform. Para obter mais informações, consulte Oracle Cloud Infrastructure Provider e Versão Mais Recente (5.30.0).

Tarefa 2: Criar Configuração do OCI

Precisamos do OCID (Oracle Cloud Identifier) do Usuário do OCI, do OCID da Tenancy, do OCID do Compartimento para configurar o provedor.

  1. Acesse a Console do OCI.

  2. Clique no ícone do perfil do usuário e selecione Meu perfil.

  3. Para obter o par de chaves da API, siga as etapas:

    1. Em Recursos, selecione Chave de API e clique em Adicionar chave de API.

    2. Você pode gerar um novo par de chaves de API ou usar sua chave pública existente para gerar um par de chaves de API. Selecione Generate API key pair. Certifique-se de fazer download da chave privada e da chave pública.

    3. Clique em Adicionar. Uma caixa de visualização do arquivo de configuração será exibida.

      Criação de Par de Chaves de API

    4. Copie os detalhes fornecidos na visualização do arquivo de configuração e salve-o em algum lugar. Isso será usado no arquivo variables.tf.

      Ela deve ter a seguinte aparência:

      [DEFAULT]
user=ocid1.user.oc1..xxxxxxxxxxx
fingerprint=xx:xx:xx:xx:xx
tenancy=ocid1.tenancy.oc1..xxxxxxxxx
region=us-phoenix-1 # your region ID
key_file=<path to your private keyfile> # TODO

    5. Clique em Fechar.

    OR

    Para obter o par de chaves de API, consulte Gerar uma configuração de chave de API na console do OCI.

Tarefa 3: Configurar o Ambiente do Terraform com Credenciais do OCI

  1. Vá para o VS Code editor e crie um novo arquivo chamado variables.tf na pasta terraform-beginners-demo e cole o código a seguir.

    variable "api_fingerprint" {
  description = "Fingerprint of OCI API private key for Tenancy"
  type        = string
}

variable "api_private_key_path" {
  description = "Path to OCI API private key used for Tenancy"
  type        = string
}

variable "tenancy_id" {
  description = "Tenancy ID where to create resources for Tenancy"
  type        = string
}

variable "user_id" {
  description = "User ID that Terraform will use to create resources for Tenancy"
  type        = string
}

variable "region" {
  description = "OCI region where resources will be created for Tenancy"
  type        = string
}

  2. Crie outro novo arquivo chamado terraform.tfvars e cole o código a seguir. Defina cada variável de variables.tf usando os valores do arquivo de configuração da Tarefa 2.3.

    # Identity and access parameters
api_fingerprint      = "REPLACE_BY_YOUR_FINGERPRINT" # Fingerprint of OCI API private key for Tenancy
api_private_key_path = "~/.oci/oci_api_key.pem"      # Path to OCI API private key used for Tenancy
region               = "us-phoenix-1"                # OCI region where resources will be created for Tenancy
tenancy_id           = "REPLACE_YOUR_TENACY_OCID"    # Tenancy ID where to create resources
user_id              = "REPLACE_BY_YOUR_USER_OCID"   # Path to OCI API private key used for Tenancy

    Observação: No ambiente de produção, será uma prática recomendada usar o arquivo terraform.tfvars para definir as variáveis terraform para promover a segurança e a escalabilidade. Para obter mais informações, consulte Arquivos de Definições de Variável (.tfvars).

Tarefa 4: Testar a Conectividade do Terraform com sua Tenancy do OCI

  1. Crie um novo arquivo chamado data_source.tf na pasta terraform-beginners-demo e copie o código a seguir.

    data "oci_identity_availability_domains" "ad" {
    #Required
    compartment_id = var.tenancy_id
}

  2. Crie um novo arquivo chamado output.tf na pasta terraform-beginners-demo e copie o código a seguir.

    output "list_ads" {
  value = data.oci_identity_availability_domains.ad.availability_domains
}

  3. Abra um novo terminal no VS Code e execute os comandos a seguir para executar o script terraform.

    Command 1: terraform init

Command 2: terraform plan #to view your deployments what is going to be created

Command 3: terraform apply #then type "yes" once prompted alternatively run "apply -auto-approve

    Workflow de Execução do Terraform

    Agora você deverá ser capaz de ver a lista de domínios de disponibilidade e o compartimento associado a eles em saídas.

    Domínios de Disponibilidade do OCI

    Agora você configurou com sucesso seu sistema para implantar recursos na tenancy do OCI no Terraform. Você especificou as variáveis, mas não fez nenhuma alteração na sua tenancy. Vamos percorrer algumas amostras para ajudá-lo a entender melhor o processo de adição, encadeamento e destruição de recursos usando o Terraform.

Tarefa 5: (Exemplo) Implantar uma Instância do OCI Compute usando o Terraform

Agora, vamos aproveitar o que você criou em tarefas anteriores para implantar recursos de rede e computação.

  1. Crie um arquivo chamado networking.tf e copie o código a seguir.

    resource "oci_core_vcn" "test_vcn" {
  count = (var.create_new_vcn) ? 1 : 0

  #Required
  compartment_id = var.compartment_id


  cidr_block   = var.vcn_cidr_block
  display_name = var.vcn_display_name
  dns_label    = var.vcn_dns_label
}

    Observação: Para obter mais informações sobre a variável core-vcn com configurações adicionais, consulte oci_core_vcn.

  2. Edite o arquivo variables.tf e adicione as variáveis a seguir.

    #VCN specific variables
variable "create_new_vcn" {
  description = "Boolean variable to specify whether to create a new VCN or to reuse an existing one."
  type        = bool
}

variable "compartment_id" {
  description = "OCI compartment where resources will be created"
  type        = string
}

variable "vcn_cidr_block" {
  description = "The list of IPv4 CIDR blocks the VCN will use"
  type        = string
}

variable "vcn_display_name" {
  description = "provide a descriptive name for the VCN - this is what you will see displayed in the OCI console"
  type        = string
}

variable "vcn_dns_label" {
  description = "provide a descriptive alphanumeric name for the DNS - this is what you will see displayed in the OCI console"
  type        = string
}

variable "vcn_id" {
  description = "provide your existing VCN OCID if create_new_vcn = false"
  type = string
}

variable "private_subnet_id" {
  description = "provide existing private subnet OCID"
  type = string
}

variable "public_subnet_id" {
  description = "provide existing public subnet OCID"
  type = string
}

  3. Adicione as novas variáveis em terraform.tfvars e defina cada variável de acordo com a configuração da tenancy.

    # VCN specific variables
create_new_vcn = true # Set this to true if you want terraform to crearte the network for you, otherwise set it to false.
compartment_id   = "REPLACE_BY_YOUR_COMPARTMENT_OCID" # add your own compartment id where the vcn will be created 
vcn_cidr_block   = "10.0.0.0/16"                      # The list of IPv4 CIDR blocks the VCN will use
vcn_display_name = "terraform_vcn_example"   # provide a descriptive name for the VCN - this is what you will see displayed in the OCI console
vcn_dns_label    = "terraformvcn"                     # provide a descriptive alphanumeric name for the DNS - this is what you will see displayed in the OCI console

# Configure CIDR Blocks, Subnet(Public, Private) OCIDS for an existing VCN. #
vcn_id            = "REPLACE_BY_YOUR_VCN_OCID"             #ADD WITH YOUR VCN OCID
private_subnet_id = "REPLACE_BY_YOUR__PRIVATE_SUBNET_OCID" #ADD WITH YOUR PRIVATE SUBNET
public_subnet_id  = "REPLACE_BY_YOUR_PUBLIC_SUBNET__OCID"  #AA WITH YOUR PUBLIC SUBNET

    Observação: Se você já tiver uma VCN existente, defina create_new_vcn como falso e modifique as variáveis vcn_id, private_subnet_id e public_subnet_id.

  4. Crie sub-redes para sua nova VCN.

    1. No arquivo networking.tf, adicione o código a seguir para criar suas sub-redes públicas e privadas.

      resource "oci_core_subnet" "private_subnet" {
  count = (var.create_new_vcn) ? 1 : 0

  #Required
  cidr_block     = var.private_subnet_cidr_block
  compartment_id = var.compartment_id
  vcn_id         = oci_core_vcn.test_vcn.*.id[0]

  display_name               = var.private_subnet_display_name
  prohibit_public_ip_on_vnic = var.private_subnet_prohibit_public_ip_on_vnic
}

resource "oci_core_subnet" "public_subnet" {
  count = (var.create_new_vcn) ? 1 : 0

  #Required
  cidr_block     = var.public_subnet_cidr_block
  compartment_id = var.compartment_id
  vcn_id         = oci_core_vcn.test_vcn.*.id[0]


  display_name               = var.public_subnet_display_name
  prohibit_public_ip_on_vnic = var.public_subnet_prohibit_public_ip_on_vnic
  route_table_id             = oci_core_route_table.test_route_table.*.id[0]
}

      Observação: Para obter mais informações sobre a variável core-subnet com configurações adicionais, consulte oci_core_subnet.

    2. Adicione as novas variáveis de sub-rede ao arquivo variables.tf copiando o código a seguir.

        #Private subnet variables
variable "private_subnet_cidr_block" {
  description = "OCI private subnet CIDR block range"
  type        = string
}


variable "private_subnet_display_name" {
  description = "provide a descriptive name for the private subnet - this is what you will see displayed in the OCI console"
  type        = string
}


variable "private_subnet_prohibit_public_ip_on_vnic" {
  description = "Allow public IP address to the VNIC"
  type        = bool
}


#Public subnet variables
variable "public_subnet_cidr_block" {
  description = "OCI public subnet CIDR block range"
  type        = string
}


variable "public_subnet_display_name" {
  description = "provide a descriptive name for the public subnet - this is what you will see displayed in the OCI console"
  type        = string
}


variable "public_subnet_prohibit_public_ip_on_vnic" {
  description = "Allow public IP address to the VNIC"
  type        = bool
}

    3. Declare as novas variáveis de sub-rede no arquivo terrform.tfvars.

      #Private subnet variables
private_subnet_cidr_block                 = "10.0.1.0/24"                               # OCI private subnet CIDR block range
private_subnet_display_name               = "terraform_private_subnet_example" # provide a descriptive name for the private subnet - this is what you will see displayed in the OCI console
private_subnet_prohibit_public_ip_on_vnic = false                                       # Allow public IP address to the VNIC

#Public subnet variables
public_subnet_cidr_block                 = "10.0.2.0/24"                              # OCI public subnet CIDR block range
public_subnet_display_name               = "terraform_public_subnet_example" # provide a descriptive name for the public subnet - this is what you will see displayed in the OCI console
public_subnet_prohibit_public_ip_on_vnic = false

  5. Adicione o código a seguir no arquivo networking.tf para criar um gateway de internet.

    resource "oci_core_internet_gateway" "test_internet_gateway" {
  count = (var.create_new_vcn) ? 1 : 0

  #Required
  compartment_id = var.compartment_id
  display_name   = "INTERNET_GTWFOR_${var.vcn_display_name}"
  vcn_id         = oci_core_vcn.test_vcn.*.id[0]
  #route_table_id = oci_core_route_table.test_route_table.id
}

  6. Adicione o código a seguir em networking.tf para a tabela de roteamento a fim de gerenciar o tráfego para a internet.

    resource "oci_core_route_table" "test_route_table" {
  count = (var.create_new_vcn) ? 1 : 0

  #Required
  compartment_id = var.compartment_id
  vcn_id         = oci_core_vcn.test_vcn.*.id[0]


  route_rules {
    #Required
    network_entity_id = oci_core_internet_gateway.test_internet_gateway.*.id[0]


    description      = "route rule internet access for ${var.vcn_display_name}"
    destination      = "0.0.0.0/0"
    destination_type = "CIDR_BLOCK"
  }
}

  7. Crie o Grupo de Segurança de Rede (NSG) associado à VCN. Copie o código a seguir no arquivo networking.tf.

    resource "oci_core_network_security_group" "test_nsg" {
  count = (var.create_new_vcn) ? 1 : 0

  #Required
  compartment_id = var.compartment_id
  vcn_id         = oci_core_vcn.test_vcn.*.id[0]
  display_name   = "NETWORK_SECURITY_GROUP_${var.vcn_display_name}"
  freeform_tags  = { "Lab" = "Terraofm 101 Guide" }
}

  8. Agora, criaremos 2 novos arquivos, compute_linux.tf e compute_windows.tf, para implantar uma VM Linux e uma VM Windows.

  9. Em compute_linux.tf, copie o código a seguir para criar uma instância de computação com um SO Linux.

    resource "oci_core_instance" "test_linux_instance" {
  #Required
  count = var.create_linux_instance ? 1 : 0

  availability_domain = data.oci_identity_availability_domains.ad.availability_domains[0].name
  compartment_id      = var.compartment_id


  create_vnic_details {
    assign_public_ip       = "true"
    display_name           = var.instance_display_name
    nsg_ids                = []
    skip_source_dest_check = "false"
    subnet_id              = var.create_new_vcn ? oci_core_subnet.public_subnet.*.id[0] : var.public_subnet_id
  }

  display_name = "${var.instance_display_name}_linux"

  metadata = {
    ssh_authorized_keys = "${file(var.public_ssh_key)}"
  }

  shape = var.instance_shape
  shape_config {

    memory_in_gbs = var.instance_flex_memory_in_gbs
    ocpus         = var.instance_flex_ocpus
  }

  launch_options {
    boot_volume_type                    = "PARAVIRTUALIZED"
    firmware                            = "UEFI_64"
    is_consistent_volume_naming_enabled = "true"
    is_pv_encryption_in_transit_enabled = "true"
    network_type                        = "PARAVIRTUALIZED"
    remote_data_volume_type             = "PARAVIRTUALIZED"

  }

  source_details {
    #Required
    source_id   = var.linux_image_ocid
    source_type = "image"

  }
  preserve_boot_volume = false
}

  10. Em compute_windows.tf, copie o código a seguir.

    resource "oci_core_instance" "test_windows_instance" {
  #Required
  count = var.create_windows_instance ? 1 : 0


  availability_domain = data.oci_identity_availability_domains.ad.availability_domains[0].name
  compartment_id      = var.compartment_id



  create_vnic_details {
    assign_public_ip       = "true"
    display_name           = var.instance_display_name
    nsg_ids                = []
    skip_source_dest_check = "false"
    subnet_id              = var.create_new_vcn ? oci_core_subnet.public_subnet.*.id[0] : var.public_subnet_id


  }

  display_name = "${var.instance_display_name}_windows"

  metadata = {
  }

  shape = var.instance_shape
  shape_config {

    memory_in_gbs = var.instance_flex_memory_in_gbs
    ocpus         = var.instance_flex_ocpus
  }

  launch_options {
    boot_volume_type                    = "PARAVIRTUALIZED"
    firmware                            = "UEFI_64"
    is_pv_encryption_in_transit_enabled = "true"
    network_type                        = "PARAVIRTUALIZED"
    remote_data_volume_type             = "PARAVIRTUALIZED"

  }

  source_details {
    #Required
    source_id   = var.windows_image_ocid
    source_type = "image"

  }
  preserve_boot_volume = false
}

  11. Atualize variables.tf com as novas variáveis para compute_linux e compute_windows.

    #Compute variables
variable "instance_shape" {
  description = "value"
  type        = string
}


variable "instance_flex_memory_in_gbs" {
  description = "(Updatable) The total amount of memory available to the instance, in gigabytes."
  type        = number
}


variable "instance_flex_ocpus" {
  description = "(Updatable) The total number of OCPUs available to the instance."
  type        = number
}


variable "instance_create_vnic_details_assign_public_ip" {
  description = "To allow compute connectivity from internet"
  type        = bool
}


variable "instance_display_name" {
  description = "provide a descriptive name for the compute instance - this is what you will see displayed in the OCI console"
  type        = string
}


variable "public_ssh_key" {
  description = "Add your public ssh key - for provisioning your compute instance"
  type        = string
}


variable "private_ssh_key" {
  description = "Add your private ssh key - for accessing your compute instance after creation"
  type        = string
}


variable "create_linux_instance" {
  description = "Boolean variable to specify whether to provision a Linux instances"
  type        = bool
}


variable "create_windows_instance" {
  description = "Boolean variable to specify whether to provision a Windows instances"
  type        = bool
}


variable "windows_image_ocid" {
  description = "OCID of the Windows image to use"
  type        = string
}


variable "linux_image_ocid" {
  description = "OCID of the Linux image to use"
  type        = string
}

  12. Adicione e defina as novas variáveis em terraform.tfvars.

    #Compute variables - Make sure to select a compatible shape (e.g.: VM.Standard.E4.Flex)
instance_shape                                = "VM.Standard.E5.Flex"                # Shape of the compute instance 
instance_flex_memory_in_gbs                   = 16                                   # (Updatable) The total amount of memory available to the instance, in gigabytes.
instance_flex_ocpus                           = 1                                    # (Updatable) The total number of OCPUs available to the instance.
instance_create_vnic_details_assign_public_ip = true                                 # To allow compute connectivity from internet
instance_display_name                         = "terraform_compute_example" # provide a descriptive name for the compute instance - this is what you will see displayed in the OCI console

#SSH keys https://docs.oracle.com/en/learn/generate_ssh_keys/index.html#introduction
public_ssh_key  = "~/cloudshellkey.pub" # Add your public ssh key
private_ssh_key = "~/cloudshellkey"     # Add your private ssh key

create_linux_instance   = true # if set to true a test linux instance will be created and false no linux instance will be deployed.
create_windows_instance = true # # If set to true a test windows instance will be created and false no windows instance will be deployed.

linux_image_ocid   = "REPLACE_BY_YOUR_REGION_LINUX_IMAGE_OCID"   # OCID for chosen image (Oracle Linux 9 example) specific to the test region (us-phoenix-1)
windows_image_ocid = "REPLACE_BY_YOUR_REGION_WINDOWS_IMAGE_OCID" # OCID for chosen image (Windows example) specific to each region (us-phoenix-1)

# Here are other image OCIDs for popular region (Ashburn, San Jose, Toronto)
# Ashburn
# Oracle linux image_id = ocid1.image.oc1.iad.aaaaaaaau7uaok7n5qd4nivgiyfatfdddhltmxddtfbyqg3bsg3fxk6z6aqq
# Windows image_id = ocid1.image.oc1.iad.aaaaaaaamaaiupezxbrw6fji5ndk3jdujwhjuexcafheqjqf45g6nzyblz6a

#San Jose
# Oracle linux image_id = ocid1.image.oc1.us-sanjose-1.aaaaaaaabjixxpfouczgpcnpvgny5pcqtgjgi3nincszbfdkd2xr4jvzahua
# Windows image_id = ocid1.image.oc1.us-sanjose-1.aaaaaaaatmjlzoqw5gzohjvygzcm5rpugomxyfho5xi6subjchoxnxo4wcfa

#Toronto
# Oracle linux image_id = ocid1.image.oc1.ca-toronto-1.aaaaaaaai6uhjrtajuuitl5hara5brnvwqvq4aebenmnbehv2cila75xbvzq
# Windows image_id = ocid1.image.oc1.ca-toronto-1.aaaaaaaaeged3obrrmmwvyruvknszy23btvb2fqu7vn3c5azeecbj2prm64q

# for other image OCIDs: https://docs.oracle.com/en-us/iaas/images/

    Observação: Os OCIDs de imagem são específicos de cada região. No código acima, há OCIDs de imagens para regiões populares e você pode encontrar OCIDs de Imagem para todas as outras regiões aqui: Todas as Famílias de Imagens.

  13. Em output.tf, copie o código a seguir. Isso imprimirá os recursos criados no terminal.

    # Regions
output "linux_instance_region" {
  value = oci_core_instance.test_linux_instance.*.region
}

output "windows_instance_region" {
  value = oci_core_instance.test_windows_instance.*.region
}

# Networking
output "network_vcn_name" {
  value = oci_core_vcn.test_vcn.*.display_name
}

# Compute: Linux Test Instance
output "output_linux_instance_display_name" {
  value = oci_core_instance.test_linux_instance.*.display_name
}

output "output_linux_instance_public_ip" {
  value = oci_core_instance.test_linux_instance.*.public_ip
}

output "output_linux_instance_state" {
  value = oci_core_instance.test_linux_instance.*.state
}

# Compute: Windows Test Instance
output "output_windows_instance_display_name" {
  value = oci_core_instance.test_windows_instance.*.display_name
}

output "output_windows_instance_public_ip" {
  value = oci_core_instance.test_windows_instance.*.public_ip
}

output "output_windows_instance_state" {
  value = oci_core_instance.test_windows_instance.*.state
}

  14. Abra o novo terminal para terraform-example e execute os comandos a seguir.

    Command 1: terraform init

Command 2: terraform plan

Commnad 3: terraform apply (and then respond "yes") OR terraform apply -auto-approve

    Você deverá ver a saída a seguir e uma VCN, sub-rede privada e sub-rede pública, tabela de roteamento, gateway de internet, nsg, VM Linux e VM Windows deverão ser criadas.

    Exemplo de Execução do Terminal do Terraform

  15. Os recursos agora foram implantados usando o Terraform. Depois de verificar a criação de recursos na tenancy do OCI, use o comando a seguir para destruir todos os recursos.

    Command: terraform destroy

Próximas Etapas

Agora você criou a conexão com o Terraform e aprendeu a implantar, atualizar e destruir recursos com um exemplo simples. Para continuar sua jornada do Terraform na OCI e se preparar para a Certificação OCI Architect Professional, confira Acelere a Certificação Oracle Cloud Infrastructure Architect Professional com o Terraform.

Congratulamo-nos com as contribuições dos leitores para melhorar e expandir este tutorial. Suas contribuições são altamente valorizadas na melhoria desse recurso para futuros alunos do Terraform.

Confirmações

Mais Recursos de Aprendizagem

Explore outros laboratórios em docs.oracle.com/learn ou acesse mais conteúdo de aprendizado gratuito no canal Oracle Learning YouTube. Além disso, visite education.oracle.com/learning-explorer para se tornar um Oracle Learning Explorer.

Para obter a documentação do produto, visite o Oracle Help Center.