Hinweis:

Terraform in Oracle Cloud Infrastructure testen

Einführung

Terraform ist ein von Hashicorp entwickeltes Infrastructure-as-Code-Tool (IaC), mit dem Sie Ihre Infrastruktur über mehrere Cloud-Provider hinweg mit der Terraform-Sprachsyntax HCL definieren, bereitstellen und verwalten können. Mit Terraform können Sie den gesamten Lebenszyklus Ihrer Cloud-Infrastruktur automatisieren. So können Sie Ressourcen ganz einfach konsistent und reproduzierbar erstellen, aktualisieren und skalieren. Terraform wird häufig von DevOps-Teams verwendet, um Cloud-Ressourcen zu verwalten, die Infrastruktureffizienz zu verbessern, manuelle Fehler zu reduzieren und Cloud-Ressourcen zur Versionskontrolle zu verwenden.

In diesem Tutorial können Sie mit der Nutzung von IaC für das Deployment und die Verwaltung Ihrer Cloud-Infrastruktur beginnen.

Terraform-Architekturworkflow

Terraform-Architekturworkflow

Ziele

Voraussetzungen

Aufgabe 1: Provider deklarieren

Ein Terraform-Provider bezieht sich auf ein Plug-in, das für das Verständnis und die Interaktion mit einem bestimmten Typ von Infrastruktur oder Service verantwortlich ist. Provider stellen die Brücke zwischen Terraform und den APIs der Services oder Plattformen dar, die Sie verwalten möchten. Provider ermöglichen es Terraform, effektiv mit Cloud-Plattformen zu kommunizieren und zu interagieren. Mit anderen Worten, der Terraform-Provider ist wie ein Übersetzer, der Terraform dabei unterstützt, mit verschiedenen Cloud-Services oder -Systemen zu sprechen und Ressourcen wie virtuelle Maschinen, Datenbanken und Netzwerke zu erstellen, zu verwalten und zu löschen.

Jeder Provider entspricht in der Regel einer bestimmten Cloud-Plattform (z.B. OCI, AWS, Azure, GCP) oder einem Infrastrukturservice (z.B. Kubernetes, Docker).

  1. Erstellen Sie einen Ordner mit dem Namen terraform-beginners-demo, und öffnen Sie ihn in VS Code.

  2. Installieren Sie die HashiCorp Terraform-Erweiterung in VS Code.

  3. Erstellen Sie die Dateien provider.tf und variables.tf unter dem Ordner terraform-beginners-demo.

  4. Kopieren Sie den folgenden Code in die Datei 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
}

    Hinweis: Wir haben den Code von der offiziellen Terraform-Registry-Seite verwendet. Weitere Informationen finden Sie unter Oracle Cloud Infrastructure-Provider und Neueste Version (5.30.0).

Aufgabe 2: OCI-Konfiguration erstellen

Zur Konfiguration des Providers benötigen wir OCI-Benutzer-Oracle Cloud-ID (OCID), Mandanten-OCID und Compartment-OCID.

  1. Melden Sie sich bei der OCI-Konsole an.

  2. Klicken Sie auf das Benutzerprofilsymbol, und wählen Sie Mein Profil aus.

  3. So rufen Sie das API-Schlüsselpaar ab:

    1. Wählen Sie unter Ressourcen die Option API-Schlüssel aus, und klicken Sie auf API-Schlüssel hinzufügen.

    2. Sie können entweder ein neues API-Schlüsselpaar generieren oder mit dem vorhandenen Public Key ein API-Schlüsselpaar generieren. Wählen Sie API-Schlüsselpaar generieren aus. Laden Sie den Private Key und den Public Key herunter.

    3. Klicken Sie auf Hinzufügen. Ein Vorschaufenster für Konfigurationsdateien wird angezeigt.

      API-Schlüsselpaare erstellen

    4. Kopieren Sie die in der Konfigurationsdateivorschau angegebenen Details, und speichern Sie sie irgendwo. Dies wird in der Datei variables.tf verwendet.

      Sie sollte wie folgt aussehen:

      [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. Klicken Sie auf Schließen.

    OR

    Informationen zum Abrufen des API-Schlüsselpaars finden Sie unter API-Schlüsselkonfiguration in der OCI-Konsole generieren.

Aufgabe 3: Terraform-Umgebung mit OCI-Zugangsdaten konfigurieren

  1. Gehen Sie zum VS-Codeeditor, erstellen Sie unter dem Ordner terraform-beginners-demo eine neue Datei namens variables.tf, und fügen Sie den folgenden Code ein.

    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. Erstellen Sie eine weitere neue Datei mit dem Namen terraform.tfvars, und fügen Sie den folgenden Code ein. Definieren Sie jede Variable aus variables.tf mit Ihren Konfigurationsdateiwerten aus Aufgabe 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

    Hinweis: In der Produktionsumgebung wird empfohlen, die Datei terraform.tfvars zu verwenden, um die Terraform-Variablen zu definieren, um die Sicherheit und Skalierbarkeit zu fördern. Weitere Informationen finden Sie unter Dateien mit Variablendefinitionen (.tfvars).

Aufgabe 4: Terraform-Konnektivität mit Ihrem OCI-Mandanten testen

  1. Erstellen Sie im Ordner terraform-beginners-demo eine neue Datei namens data_source.tf, und kopieren Sie den folgenden Code.

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

  2. Erstellen Sie unter dem Ordner terraform-beginners-demo eine neue Datei namens output.tf, und kopieren Sie den folgenden Code.

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

  3. Öffnen Sie einen neuen Terminal in VS Code, und führen Sie die folgenden Befehle aus, um das Terraform-Skript auszuführen.

    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

    Terraform-Ausführungsworkflow

    Jetzt sollten Sie die Liste der Availability-Domains und des damit verknüpften Compartments unter Ausgaben anzeigen können.

    OCI-Availability-Domains

    Sie haben Ihr System jetzt erfolgreich so konfiguriert, dass Ressourcen in Ihrem OCI-Mandanten in Terraform bereitgestellt werden. Sie haben die Variablen übergeben, aber keine Änderungen an Ihrem Mandanten vorgenommen. Wir werden einige Beispiele durchgehen, um Ihnen zu helfen, den Prozess des Hinzufügens, Verkettens und Zerstörens von Ressourcen mit Terraform besser zu verstehen.

Aufgabe 5: (Beispiel) OCI-Compute-Instanz mit Terraform bereitstellen

Jetzt bauen wir auf dem auf, was Sie in früheren Aufgaben zum Bereitstellen von Netzwerk- und Compute-Ressourcen erstellt haben.

  1. Erstellen Sie eine Datei namens networking.tf, und kopieren Sie den folgenden Code.

    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
}

    Hinweis: Weitere Informationen zur core-vcn-Variablen mit zusätzlichen Konfigurationen finden Sie unter oci_core_vcn.

  2. Bearbeiten Sie die Datei variables.tf, und fügen Sie die folgenden Variablen hinzu.

    #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. Fügen Sie die neuen Variablen in terraform.tfvars hinzu, und definieren Sie jede Variable entsprechend Ihrer Mandantenkonfiguration.

    # 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

    Hinweis: Wenn bereits ein VCN vorhanden ist, setzen Sie create_new_vcn auf "false", und ändern Sie die Variablen vcn_id, private_subnet_id und public_subnet_id.

  4. Subnetze für das neue VCN erstellen.

    1. Fügen Sie in der Datei networking.tf den folgenden Code hinzu, um Ihre öffentlichen und privaten Subnetze zu erstellen.

      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]
}

      Hinweis: Weitere Informationen zur Core-Subnetzvariable mit zusätzlichen Konfigurationen finden Sie unter oci_core_subnet.

    2. Fügen Sie die neuen Subnetzvariablen in die Datei variables.tf ein, indem Sie den folgenden Code kopieren.

        #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. Deklarieren Sie die neuen Subnetzvariablen in der Datei 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. Fügen Sie den folgenden Code in die Datei networking.tf ein, um ein Internetgateway zu erstellen.

    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. Fügen Sie den folgenden Code in networking.tf hinzu, damit die Routentabelle den Traffic zum Internet verwaltet.

    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. Erstellen Sie die Netzwerksicherheitsgruppe (NSG), die mit dem VCN verknüpft ist. Kopieren Sie den folgenden Code in die Datei 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. Wir erstellen jetzt 2 neue Dateien (compute_linux.tf und compute_windows.tf) für das Deployment einer Linux-VM und einer Windows-VM.

  9. Kopieren Sie in compute_linux.tf den folgenden Code, um eine Compute-Instanz mit einem Linux-BS zu erstellen.

    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. Kopieren Sie in compute_windows.tf den folgenden Code.

    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. Aktualisieren Sie variables.tf mit den neuen Variablen für in compute_linux und 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. Fügen Sie die neuen Variablen in terraform.tfvars hinzu, und definieren Sie sie.

    #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/

    Hinweis: Image-OCIDs sind für jede Region spezifisch. Im obigen Code befinden sich Image-OCIDs für beliebte Regionen. Sie finden Image-OCIDs für alle anderen Regionen hier: Alle Imagefamilien.

  13. Kopieren Sie in output.tf den folgenden Code. Dadurch werden die im Terminal erstellten Ressourcen gedruckt.

    # 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. Öffnen Sie einen neuen Terminal für terraform-example, und führen Sie die folgenden Befehle aus.

    Command 1: terraform init

Command 2: terraform plan

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

    Die folgende Ausgabe sollte angezeigt werden, und es sollten ein VCN, ein privates Subnetz und ein öffentliches Subnetz, eine Routentabelle, ein Internetgateway, eine nsg, eine Linux-VM und eine Windows-VM erstellt werden.

    Terraform-Beispielterminalausführung

  15. Ressourcen wurden jetzt mit Terraform bereitgestellt. Nachdem Sie die Ressourcenerstellung in Ihrem OCI-Mandanten geprüft haben, löschen Sie mit dem folgenden Befehl alle Ressourcen.

    Command: terraform destroy

Nächste Schritte

Sie haben jetzt die Verbindung zu Terraform aufgebaut und gelernt, Ressourcen mit einem einfachen Beispiel bereitzustellen, zu aktualisieren und zu löschen. Um Ihre Terraform-Reise in OCI fortzusetzen und sich für die OCI Architect Professional-Zertifizierung einzurichten, lesen Sie Beschleunigen Sie die Oracle Cloud Infrastructure Architect Professional-Zertifizierung mit Terraform.

Wir begrüßen Beiträge von Lesern, um dieses Tutorial zu verbessern und zu erweitern. Ihre Beiträge werden bei der Verbesserung dieser Ressource für zukünftige Terraform-Lerner hoch geschätzt.

Danksagungen

Weitere Lernressourcen

Sehen Sie sich andere Übungen zu docs.oracle.com/learn an, oder greifen Sie im Oracle Learning YouTube-Channel auf weitere kostenlose Lerninhalte zu. Besuchen Sie außerdem education.oracle.com/learning-explorer, um Oracle Learning Explorer zu werden.

Die Produktdokumentation finden Sie im Oracle Help Center.