Hinweis:

Dieses Tutorial erfordert Zugriff auf Oracle Cloud. Informationen zur Registrierung für einen kostenlosen Account finden Sie unter Erste Schritte mit Oracle Cloud Infrastructure Free Tier.
Es verwendet Beispielwerte für Oracle Cloud Infrastructure-Zugangsdaten, -Mandanten und -Compartments. Ersetzen Sie diese Werte nach Abschluss der Übung durch Werte, die für Ihre Cloud-Umgebung spezifisch sind.

Kubernetes-Cluster mit Terraform mit Oracle Cloud Infrastructure Kubernetes Engine bereitstellen

Einführung

Die Bereitstellung von Kubernetes mit Terraform auf der Oracle Cloud Infrastructure Kubernetes Engine (OCI Kubernetes Engine oder OKE) bietet einen optimierten und skalierbaren Ansatz für die Verwaltung containerisierter Anwendungen in der Cloud. OKE, ein von Oracle Cloud Infrastructure verwalteter Kubernetes-Service, vereinfacht die Bereitstellung, Verwaltung und Skalierung von Kubernetes-Clustern.

Mit Terraform, einem Infrastructure-as-Code-(IaC-)Tool, können Sie das Provisioning und die Konfiguration von OKE-Clustern automatisieren und so Konsistenz und Effizienz sicherstellen. Diese Kombination ermöglicht wiederholbare Deployments, Infrastrukturversionierung und einfache Updates und eignet sich somit ideal für cloudnative und DevOps-orientierte Teams, die das Oracle Cloud Infrastructure-Ökosystem nutzen möchten.

In diesem Tutorial stellen wir eine sehr spezifische Kubernetes-Architektur auf OCI OKE mit Terraform bereit.

Wir stellen die folgenden Komponenten bereit:

Internetgateway
NAT-Gateway
Servicegateway
7 x Subnetze (privat und öffentlich)
2 x Knotenpools
4 x Worker-Knoten (Instanzen)
Bastion (Instanz)
Operator (Instanz)

Ziele

Stellen Sie mit OKE ein Kubernetes-Cluster mit Terraform bereit.

Voraussetzungen

Um Objekte auf OCI mit Terraform bereitzustellen, müssen Sie zunächst Ihre Umgebung für die Authentifizierung und Ausführung von Terraform-Skripten vorbereiten. Weitere Informationen finden Sie unter Aufgabe 2: Umgebung auf Authentifizierung vorbereiten und Terraform-Skripte ausführen.

Aufgabe 1: Repository mit den Terraform-Skripten klonen

Klonen Sie das Repository terraform-oci-oke von hier aus: terraform-oci-oke.
1. Zum Zeitpunkt des Schreibens dieses Tutorials ist die neueste Version 5.1.8.
2. Sie können entweder die vollständige ZIP-Datei mit dem vollständigen Repository herunterladen oder das Repository mit dem Befehl git clone klonen.
3. Klicken Sie auf die Version, um auf die Verzweigung 5.1.8 zuzugreifen.
1. Beachten Sie, dass Sie sich in der Verzweigung 5.1.8 befinden.
2. Klicken Sie auf den Ordner docs.
Klicken Sie auf den Ordner src.
Klicken Sie auf die Datei SUMMARY.md.
Klicken Sie auf Getting Started.
1. Beachten Sie, dass Sie sich noch in der 5.1.8-Verzweigung befinden. Andere Verzweigungen können je nach Codeversion unterschiedliche Typen von Dokumentationsschritten enthalten.
2. Beachten Sie, dass Sie sich auf der Seite Erste Schritte befinden und diese Seite genau das tut, was der Titel sagt.
In der folgenden Ausgabe sehen Sie, wie wir dieses Tutorial auf der Seite Erste Schritte erstellen.
1. Führen Sie den Befehl git clone aus, um das Repository zu klonen.
```
iwhooge@iwhooge-mac ~ % git clone https://github.com/oracle-terraform-modules/terraform-oci-oke.git tfoke
```
2. Führen Sie den folgenden Befehl aus, um den Ordner in den Repository-Ordner zu ändern.
3. Führen Sie den folgenden Befehl aus, um den Inhalt des Ordners aufzulisten.
4. Sie können alle Dateien des Repositorys anzeigen.

Erstellen Sie eine providers.tf-Datei mit dem folgenden Inhalt in diesem Verzeichnis.

providers.tf:

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

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

Führen Sie den folgenden Befehl aus, um den Ordnerinhalt aufzulisten.
Beachten Sie, dass die Datei providers.tf erstellt wird.

Führen Sie den folgenden Befehl aus, um Terraform zu initialisieren und die erforderlichen Module upzugraden.
```
iwhooge@iwhooge-mac tfoke % terraform init --upgrade
```
Beachten Sie, dass die Meldung Terraform wurde erfolgreich initialisiert angezeigt wird.

Stellen Sie sicher, dass die folgenden Informationen verfügbar sind, um die Datei terraform.tfvars zu erstellen. Diese Informationen können mit den folgenden Schritten abgerufen werden, die hier aufgeführt werden: Aufgabe 2: Umgebung für Authentifizierung vorbereiten und Terraform-Skripte ausführen.

Mandanten-OCID	ocid1.tenancy.oc1..aaaaaaaaXXX
Benutzer-OCID	ocid1.user.oc1..aaaaaaaaXXX
Fingerprint	30:XXX
Bereich	me-abudhabi-1
Private Key-Pfad	~/.oci/4-4-2023-rsa-key.pem
Compartment-OCID	ocid1.compartment.oc1..aaaaaaaaXXX

Sie müssen in diesem Verzeichnis eine terraform.tfvars-Datei mit dem folgenden Inhalt erstellen.

terraform.tfvars:

# Identity and access parameters
api_fingerprint      = "30:XXX"
api_private_key_path = "~/.oci/4-4-2023-rsa-key.pem"

home_region = "me-abudhabi-1"
region      = "me-abudhabi-1"
tenancy_id  = "ocid1.tenancy.oc1..aaaaaaaaXXX"
user_id     = "ocid1.user.oc1..aaaaaaaaXXX"

# general oci parameters
compartment_id = "ocid1.compartment.oc1..aaaaaaaaXXX"
timezone       = "Australia/Sydney"

# ssh keys
ssh_private_key_path = "~/.ssh/id_rsa"
ssh_public_key_path  = "~/.ssh/id_rsa.pub"

# networking
create_vcn               = true
assign_dns               = true
lockdown_default_seclist = true
vcn_cidrs                = ["10.0.0.0/16"]
vcn_dns_label            = "oke"
vcn_name                 = "oke"

# Subnets
subnets = {
  bastion  = { newbits = 13, netnum = 0, dns_label = "bastion", create="always" }
  operator = { newbits = 13, netnum = 1, dns_label = "operator", create="always" }
  cp       = { newbits = 13, netnum = 2, dns_label = "cp", create="always" }
  int_lb   = { newbits = 11, netnum = 16, dns_label = "ilb", create="always" }
  pub_lb   = { newbits = 11, netnum = 17, dns_label = "plb", create="always" }
  workers  = { newbits = 2, netnum = 1, dns_label = "workers", create="always" }
  pods     = { newbits = 2, netnum = 2, dns_label = "pods", create="always" }
}

# bastion
create_bastion           = true
bastion_allowed_cidrs    = ["0.0.0.0/0"]
bastion_user             = "opc"

# operator
create_operator                = true
operator_install_k9s           = true


# iam
create_iam_operator_policy   = "always"
create_iam_resources         = true

create_iam_tag_namespace = false // true/*false
create_iam_defined_tags  = false // true/*false
tag_namespace            = "oke"
use_defined_tags         = false // true/*false

# cluster
create_cluster     = true
cluster_name       = "oke"
cni_type           = "flannel"
kubernetes_version = "v1.29.1"
pods_cidr          = "10.244.0.0/16"
services_cidr      = "10.96.0.0/16"

# Worker pool defaults
worker_pool_size = 0
worker_pool_mode = "node-pool"

# Worker defaults
await_node_readiness     = "none"

worker_pools = {
  np1 = {
    shape              = "VM.Standard.E4.Flex",
    ocpus              = 2,
    memory             = 32,
    size               = 1,
    boot_volume_size   = 50,
    kubernetes_version = "v1.29.1"
  }
  np2 = {
    shape            = "VM.Standard.E4.Flex",
    ocpus            = 2,
    memory           = 32,
    size             = 3,
    boot_volume_size = 150,
    kubernetes_version = "v1.30.1"
  }
}

# Security
allow_node_port_access       = false
allow_worker_internet_access = true
allow_worker_ssh_access      = true
control_plane_allowed_cidrs  = ["0.0.0.0/0"]
control_plane_is_public      = false
load_balancers               = "both"
preferred_load_balancer      = "public"

Führen Sie den folgenden Befehl aus, um den Ordnerinhalt aufzulisten.
Beachten Sie, dass die Datei terraform.tfvars erstellt wird.

Aufgabe 2: Terraform Apply ausführen und ein OKE-Cluster mit den erforderlichen Ressourcen (VCN, Subnetze usw.) erstellen

Führen Sie den folgenden Befehl aus, um das Kubernetes-Cluster-Deployment auf OKE mit Terraform zu planen.
```
iwhooge@iwhooge-mac tfoke % terraform plan
```
1. Beachten Sie, dass dieser Terraform-Code 77 Objekte bereitstellt.
2. Führen Sie den Befehl terraform apply aus.
Führen Sie den folgenden Befehl aus, um das Kubernetes-Cluster-Deployment mit Terraform auf OKE anzuwenden.
```
iwhooge@iwhooge-mac tfoke % terraform apply
```
1. Beachten Sie, dass dieser Terraform-Code 77 Objekte bereitstellt.
2. Geben Sie yes ein, um das Deployment fortzusetzen.
Nach Abschluss des Deployments wird eine Meldung angezeigt, dass die Anwendung abgeschlossen ist.

Beachten Sie die Ausgabe, die nützliche Informationen enthält, die Sie möglicherweise zur Referenz benötigen.

Ausgabe:

apiserver_private_host = "10.0.0.22"

availability_domains = tomap({

  "1" = "cAtJ:ME-ABUDHABI-1-AD-1"

})

bastion_id = "ocid1.instance.oc1.me-abudhabi-1.anqxkljrpkxxxxxx5chephxjadkxqa2ekxksb5gokj4q"

bastion_nsg_id = "ocid1.networksecuritygroup.oc1.me-abudhabi-1.aaaaaxxxxxxxxxxxy5qm22odw7by37h77ki6cosoqd7pzwq"

bastion_public_ip = "129.151.149.237"

bastion_subnet_cidr = "10.0.0.0/29"

bastion_subnet_id = "ocid1.subnet.oc1.me-abudhabi-1.aaaaaaaxxxxxxxxxxxxxxxxmyzp6f2czibfr6534evfkt7m2a"

cluster_endpoints = tomap({

  "kubernetes" = ""

  "private_endpoint" = "10.0.0.22:6443"

  "public_endpoint" = ""

  "vcn_hostname_endpoint" = "cbyedhyevbq.cp.oke.oraclevcn.com:6443"

})

cluster_id = "ocid1.cluster.oc1.me-abudhabi-1.aaaaaaaxxxxxxxxxxxxx57gz5q26hmpzkbcbyedhyevbq"

control_plane_nsg_id = "ocid1.networksecuritygroup.oc1.me-abudhabi-1.aaaaaaaavxvgoewcgxxxxxxxxxxxxx6psycdz6zz5gaf6re4kcxa"

control_plane_subnet_cidr = "10.0.0.16/29"

control_plane_subnet_id = "ocid1.subnet.oc1.me-abudhabi-1.aaaaaaaajvvpdmuixxxxxxxxxxxjkpx77hqu3v2s4qilnp56a"

dynamic_group_ids = tolist([

  "ocid1.dynamicgroup.oc1..aaaaaaaafsikvwgexxxxxxxxx5tx2u4c2s2eic4sslwyabva",

])

ig_route_table_id = "ocid1.routetable.oc1.me-abudhabi-1.aaaaaaaalxxxxxxxxxxxxxxcyzrl2af4ihrkhcjttu2w7aq"

int_lb_nsg_id = "ocid1.networksecuritygroup.oc1.me-abudhabi-1.aaaaaaaanwppaafc7fyiwcoyhjxxxxxxxxxxxxxxxxx6a6752l7547gxg7ea"

int_lb_subnet_cidr = "10.0.2.0/27"

int_lb_subnet_id = "ocid1.subnet.oc1.me-abudhabi-1.aaaaaaaawo5xmcwwbzk3gxxxxxxxxxxxxxxxxxxjjfllbvsdauaq"

lpg_all_attributes = {}

nat_route_table_id = "ocid1.routetable.oc1.me-abudhabi-1.aaaaaaaapqn3uqtszdcxxxxxxxxxxxxxxxxxliwveow232xgffigq"

operator_id = "ocid1.instance.oc1.me-abudhabi-1.anqxkljrpkbrwsac5exxxxxxxxxxxxxxxxxxxxxxxrfdxsjdfzmq56jja"

operator_nsg_id = "ocid1.networksecuritygroup.oc1.me-abudhabi-1.aaaaaaaao5kh3z3eaf4zhbtxixxxxxxxxxxxxxxxxxxxxxevyds3cbrjqzthv5ja"

operator_private_ip = "10.0.0.14"

operator_subnet_cidr = "10.0.0.8/29"

operator_subnet_id = "ocid1.subnet.oc1.me-abudhabi-1.aaaaaaaa6vnirazbox2edmtnxrzhxxxxxxxxxxxxxxxxxxxishk7556iw6zyq"

pod_subnet_cidr = "10.0.128.0/18"

pod_subnet_id = "ocid1.subnet.oc1.me-abudhabi-1.aaaaaaaasfnwg3lnyphk5h275r46ksi3xxxxxxxxxxxxxxxxxxxxxxxqz25iwkcinxa"

policy_statements = tolist([

  "Allow dynamic-group oke-operator-lccwyk to MANAGE clusters in compartment id ocid1.compartment.oc1..aaaaaaaa323ijv54zwkwbz2hhr2nnqoywlpxxxxxxxxxxxxxxxxxxxxxxxtecokaq4h4a",

])

pub_lb_nsg_id = "ocid1.networksecuritygroup.oc1.me-abudhabi-1.aaaaaaaae5stez5u26g6x75dy5nf72mfcixxxxxxxxxxxxxxxxxxxxxxxx2nwkwv5nkaa"

pub_lb_subnet_cidr = "10.0.2.32/27"

pub_lb_subnet_id = "ocid1.subnet.oc1.me-abudhabi-1.aaaaaaaagr5j2l6tu3rmroejg6t4nrixxxxxxxxxx6oar6xcirvq"

ssh_to_bastion = "ssh -i ~/.ssh/id_rsa opc@129.xxx.xxx.xxx"

ssh_to_operator = "ssh -o ProxyCommand='ssh -W %h:%p -i ~/.ssh/id_rsa opc@129.xxx.xxx.xxx' -i ~/.ssh/id_rsa opc@10.0.0.14"

state_id = "lccwyk"

vcn_id = "ocid1.vcn.oc1.me-abudhabi-1.amaaaaaapkbrwsaatndqrw3xq7e7krqfxxxxxxxxxxxxxxxpywz4qvhida"

worker_nsg_id = "ocid1.networksecuritygroup.oc1.me-abudhabi-1.aaaaaaaazbpfavygiv4xy3khfi7cxunixxxxxxxxxxxxxxxxjvsm6jqtja"

worker_pool_ids = {

  "np1" = "ocid1.nodepool.oc1.me-abudhabi-1.aaaaaaaauo57ekyoiiaif25gq7uwrpxxxxxxxxxxxxxxpsnygeam7t2wa"

  "np2" = "ocid1.nodepool.oc1.me-abudhabi-1.aaaaaaaa7423cp6zyntxwxokol3kmdxxxxxxxxxxxxx3wnayv2xq6nyq"

}

worker_pool_ips = {

  "np1" = {

    "ocid1.instance.oc1.me-abudhabi-1.anqxkljrpkbrwsac3t3smjsyxjgen4zqjpxxxxxxxxxxxxx663igu7cznla" = "10.0.90.37"

  }

  "np2" = {

    "ocid1.instance.oc1.me-abudhabi-1.anqxkljrpkbrwsac2eayropnzgazrxxxxxxxxxxxxxxxxpiykrq4r5pbga" = "10.0.125.238"

    "ocid1.instance.oc1.me-abudhabi-1.anqxkljrpkbrwsace4aup47ukjcedxxxxxxxxxxxxxxxxxx2hdxbsyiitva" = "10.0.92.136"

    "ocid1.instance.oc1.me-abudhabi-1.anqxkljrpkbrwsacojjri4b7qsaxxxxxxxxxxxxxxxxxnarf75ejv7a2a" = "10.0.111.157"

  }

}

worker_subnet_cidr = "10.0.64.0/18"

worker_subnet_id = "ocid1.subnet.oc1.me-abudhabi-1.aaaaaaaarrnazbrmwbiyl3ljmdxhgmxxxxxxxxxxxxxxxxxxxv3wtgmiucnsa"

iwhooge@iwhooge-mac tfoke %

Aufgabe 3: Terraform-Deployment in der OCI-Konsole bestätigen

Navigieren Sie zur OCI-Konsole, und bestätigen Sie die folgenden Terraform-Deployments.

OCI-Kubernetes-Engine-Cluster
- Gehen Sie zur OCI-Konsole.
  1. Navigieren Sie zu Entwicklerservices, und klicken Sie auf Kubernetes-Cluster (OKE).
  2. Klicken Sie auf das in Aufgabe 2 erstellte Kubernetes-Cluster für oke.
- Bildlauf nach unten.
  1. Klicken Sie auf Knotenpools.
  2. Klicken Sie auf den Knotenpool np1.
- Bildlauf nach unten.
- Beachten Sie, dass sich im Knotenpool np1 ein Worker-Knoten befindet.
- Gehen Sie zur vorherigen Seite, und klicken Sie auf den Knotenpool np2.
- Bildlauf nach unten.
- Beachten Sie, dass sich im Knotenpool np2 drei Worker-Knoten befinden.
Instanzen
- Gehen Sie zur OCI-Konsole.
  1. Navigieren Sie zu Compute, und klicken Sie auf Instanzen.
  2. Prüfen Sie die vier Worker-Knoten des Kubernetes-Clusters.
  3. Prüfen Sie den Operator des Kubernetes-Clusters.
  4. Prüfen Sie, ob der Bastion-Host zum Kubernetes-Cluster gehört.
Virtuelles Cloud-Netzwerk
- Gehen Sie zur OCI-Konsole, navigieren Sie zu Networking, Virtuelle Cloud-Netzwerke, und klicken Sie auf das oke-VCN.
- Klicken Sie auf Subnetze, und Sie können alle sieben Subnetze des Kubernetes-Clusters anzeigen.
- Die folgende Abbildung zeigt, was wir bisher mit dem Terraform-Skript erstellt haben.

Aufgabe 4: Verbindung mit Bastion und Operator prüfen

In der Ausgabe finden Sie einige Befehle zum Herstellen einer Verbindung zu Ihrer Kubernetes-Umgebung, wenn das Terraform-Deployment abgeschlossen ist.

Führen Sie den folgenden Befehl aus, um eine Verbindung zum Bastionhost herzustellen.
```
ssh_to_bastion = "ssh -i ~/.ssh/id_rsa opc@129.xxx.xxx.xxx"
```

Führen Sie den folgenden Befehl aus, um eine Verbindung zum Kubernetes-Operator über den Bastionhost herzustellen.

ssh_to_operator = "ssh -o ProxyCommand='ssh -W %h:%p -i ~/.ssh/id_rsa opc@129.xxx.xxx.xxx' -i ~/.ssh/id_rsa opc@10.0.0.14"

Wir verwalten das Kubernetes-Cluster vom Betreiber. Geben Sie yes zweimal ein, und führen Sie den Befehl kubectl get nodes aus, um die Kubernetes-Worker-Knoten abzurufen.

Um SSH-Verbindungen zu vereinfachen, fügen Sie die folgenden zusätzlichen Befehle in die Datei ~/.ssh/config ein.

Host bastion47
    HostName 129.xxx.xxx.xxx
    user opc
    IdentityFile ~/.ssh/id_rsa
    UserKnownHostsFile /dev/null
    StrictHostKeyChecking=no
    TCPKeepAlive=yes
    ServerAliveInterval=50

Host operator47
    HostName 10.0.0.14
    user opc
    IdentityFile ~/.ssh/id_rsa
    ProxyJump bastion47
    UserKnownHostsFile /dev/null
    StrictHostKeyChecking=no
    TCPKeepAlive=yes
    ServerAliveInterval=50

Nachdem Sie den folgenden Inhalt zur Datei ~/.ssh/config hinzugefügt haben, können Sie einfache Namen in den SSH-Befehlen verwenden.

iwhooge@iwhooge-mac tfoke % ssh operator47

Aufgabe 5: Kubernetes-Cluster mit Terraform löschen

Führen Sie den Befehl terraform destroy aus, um das Kubernetes-Cluster in OKE zu löschen.
```
iwhooge@iwhooge-mac tfoke % terraform destroy
```
Geben Sie yes ein.

Nach Abschluss des Löschprozesses wird eine Meldung angezeigt, dass das Löschen abgeschlossen ist.

Nächste Schritte

Das Deployment des Kubernetes-Clusters auf der OCI Kubernetes Engine mit Terraform bietet eine effiziente, automatisierte und skalierbare Lösung für die Verwaltung containerisierter Anwendungen in der Cloud.

Durch die Nutzung der IaC-Funktionen von Terraform stellen Sie sicher, dass Ihre Kubernetes-Cluster konsistent bereitgestellt werden und im Laufe der Zeit einfach verwaltet oder aktualisiert werden können.

Diese Integration optimiert den Prozess und ermöglicht eine bessere Versionskontrolle, automatisierte Skalierung und ein wiederholbares Infrastruktursetup. Unabhängig davon, ob Sie ein einzelnes Cluster verwalten oder umgebungsübergreifend skalieren, ermöglicht dieser Ansatz Teams die zuverlässige und einfache Verwaltung ihrer Kubernetes-Workloads in Oracle Cloud Infrastructure.

Danksagungen

Autor - Iwan Hoogendoorn (OCI Network Specialist)

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.

Titel und Copyright-Informationen

Deploy a Kubernetes Cluster with Terraform using Oracle Cloud Infrastructure Kubernetes Engine

G18099-01

October 2024

Oracle und/oder verbundene Unternehmen.