Oracle Cloud Infrastructure Kubernetes Engine-Cluster mit Terraform erstellen
Einführung
In diesem Tutorial zeigen wir, wie Sie ein Oracle Cloud Infrastructure Kubernetes Engine-(OKE-)Cluster mit Terraform erstellen und Ihren Terraform-Code mit Oracle Resource Manager verwalten. Mit diesem Ansatz können Sie Infrastructure-as-Code-Prinzipien (IaC) implementieren und die Automatisierung, Konsistenz und Wiederholbarkeit in Ihren Deployments verbessern.
Oracle Cloud Infrastructure Kubernetes Engine (OKE)
Kubernetes (K8s) ist eine Open-Source-Plattform zur Automatisierung der Bereitstellung, Skalierung und Verwaltung von containerisierten Anwendungen. Ursprünglich von Google entwickelt und jetzt von der CNCF gepflegt, ist es der Industriestandard für die Ausführung cloudnativer Anwendungen in großem Maßstab.
OKE ist ein vollständig verwalteter Service auf Oracle Cloud Infrastructure (OCI), der das Deployment und die Verwaltung von Kubernetes-Clustern vereinfacht. Es automatisiert das Control Plane- und Worker-Knotenmanagement, integriert sich in die Netzwerk-, Speicher- und Sicherheitsservices von OCI und unterstützt sowohl zustandslose als auch zustandsbehaftete Workloads. OKE-Knoten sind in Knotenpools organisiert, die einfach skaliert und verwaltet werden können. So werden High Availability und optimale Ressourcenauslastung für containerisierte Anwendungen sichergestellt. OKE folgt dem Standard-Kubernetes-Modell mit zwei Schlüsselkomponenten (verwaltete Control Plane und einer vom Kunden verwalteten Data Plane).
-
Control Plane: Vollständig von Oracle verwaltet und die zugehörigen Komponenten übernehmen die Orchestrierung und Verwaltung des Clusters:
kube-apiserver
: Zentrale API für die Kommunikation mit dem Cluster.etcd
: Speichert die Konfiguration und den Status des Clusters.kube-scheduler
: Weist Pods geeigneten Knoten zu.kube-controller-manager
: Stellt den gewünschten Status sicher, indem Controller verwaltet werden.cloud-controller-manager
(CCM): Integration mit OCI zur Verwaltung von Cloud-Ressourcen wie OCI Load Balancer und OCI Block Volumes.
-
Data Plane: Wird im Kundenmandanten bereitgestellt und führt die tatsächlichen Workloads aus. Es besteht aus:
Worker Nodes
: Compute-Instanzen (vom Kunden bereitgestellt), die Pods ausführen.kubelet
: Knoten-Agent, der die Podausführung verwaltet.kube-proxy
: Verarbeitet Netzwerkregeln und leitet Traffic zu/von Pods weiter.
Weitere Informationen finden Sie unter OCI Kubernetes Engine mit verschiedenen Kapazitätstypen verwalten und häufige Probleme auf präemptiven Knoten beheben.
Architektur
Die folgende Referenzarchitektur wird zur Demonstration der Erstellung des OKE-Clusters verwendet.
Das Diagramm veranschaulicht eine robuste OKE-Architektur, die in einer einzelnen OCI-Region bereitgestellt wird und auf mehrere Faultdomains (FDs) verteilt ist. Das Setup umfasst ein virtuelles Cloud-Netzwerk (VCN) mit drei verschiedenen Subnetzen: ein öffentliches Subnetz (LBSubnet), das ein Internetgateway und einen OCI-Load Balancer zum Verteilen eingehenden Traffics hostet, und zwei private Subnetze, eines für OKE-Worker-Knoten (NodeSubnet) und eines für den API-Server (APISubnet). Die Worker-Knoten werden über drei FDs innerhalb einer einzelnen Availability-Domain (AD) verteilt, wodurch das Ausfallrisiko minimiert wird. Das Cluster stellt eine nahtlose Verbindung zur OCI Container Registry her, um Containerimages zu speichern und abzurufen.
Die OCI-Konsole bietet eine einfache Point-&-Click-Methode. Navigieren Sie zur Kubernetes-Cluster-UI, um sie zu verwenden. Wählen Sie Schnellerstellung aus. Benennen Sie das Cluster. Wählen Sie einen privaten API-Endpunkt aus. Konfigurieren Sie verwaltete Worker-Knoten mit der gewünschten Ausprägung, dem gewünschten Image und der gewünschten Anzahl. Mit der Option der OCI-Konsole wird ein erweitertes OKE-Cluster eingerichtet. Es verwendet OCI_VCN_IP_NATIVE
CNI, die Standardeinstellung. Außerdem werden dedizierte private Subnetze für Worker-Knoten und den API-Endpunkt bereitgestellt. Außerdem wird ein öffentliches Subnetz für den Load Balancer erstellt. Dieser manuelle Ansatz ist jedoch zeitaufwändig und für große oder wiederholbare Deployments nicht skalierbar.
Um die Einschränkungen der manuellen Bereitstellung zu überwinden, bietet dieses Tutorial eine vereinfachte, flache Terraform-basierte Lösung, die das gesamte OKE-Clustersetup in drei Schritten automatisiert:
- Erstellen von Netzwerkressourcen.
- OKE-Cluster-Provisioning
- Worker-Knotenpoolerstellung.
Dieses Tutorial konzentriert sich auf das Deployment der Core-OKE-Clusterinfrastruktur. Anpassungen auf Anwendungsebene und Workload-spezifische Konfigurationen fallen nicht in den Geltungsbereich. Um das Provisioning zu optimieren, haben wir Bash-Skripte enthalten, mit denen die Ausführung von Terraform-Befehlen automatisiert wird. Diese Skripte wurden für die nahtlose Integration in eine dreiphasige Jenkins-Pipeline entwickelt, sodass das automatisierte Deployment der gesamten OKE-Umgebung One-Click
ermöglicht wird.
Sie lernen, wie Sie die Erstellung von Netzwerkressourcen (VCN, Gateways, Subnetze), dem OKE-Cluster und den zugehörigen Knotenpools mit der Terraform-CLI und Oracle Resource Manager automatisieren. Darüber hinaus zeigen wir, wie diese Automatisierung mit Bash, OCI-CLI und Jenkins erweitert wird, wodurch der manuelle Aufwand reduziert und eine konsistente Infrastrukturbereitstellung sichergestellt wird.
Ziele
- Erstellen Sie ein OKE-Cluster mit Terraform for Infrastructure as Code, und beschreiben Sie den Prozess der Verwaltung Ihres Deployments über Oracle Resource Manager. Auf dem Weg werden wir auch grundlegende OKE-Konzepte behandeln.
Voraussetzungen
-
Root-Administratorrolle des OCI-Mandanten für das anfängliche Setup, wird für die Produktion nicht empfohlen.
- Nicht-Admin-OCI-Benutzer mit erforderlichen Networking- und OKE-OCI-IAM-Policys. Weitere Informationen finden Sie unter Policy-Konfiguration für Clustererstellung und -Deployment.
-
Vertrautheit mit Infrastructure as Code-Prinzipien und Terraform (Communityversion), einschließlich:
Terraform-Automatisierung für das Erstellen von OKE-Clustern
Zum Erstellen des VCN (OKE-VCN
) und des OKE-Clusters stehen zwei Automatisierungsoptionen zur Verfügung: ein Flat-Modul oder ein Standardmodul, das untergeordnete Module nutzt. Letzterer Ansatz fällt nicht in den Anwendungsbereich dieses Artikels, bietet jedoch eine bessere Organisation und Skalierbarkeit für größere, komplexe Bereitstellungen und fördert die Wiederverwendbarkeit und Wartbarkeit von Code, was ihn ideal für Produktionsumgebungen macht. Wir verwenden den flachen und einfacheren Ansatz, der für Entwicklungsanwendungsfälle, Testszenarien oder eine einmalige Demonstration des VCN-Deployments geeignet ist. Weitere Informationen finden Sie unter terraform-oci-oke.
Aufgabe 1: OKE-Ressourcen mit Terraform bereitstellen (Community Edition)
Bevor Sie Terraform-Befehle zum Planen und Bereitstellen Ihrer Infrastruktur mit der Terraform-CLI ausführen, aktualisieren Sie die bereitgestellte Terraform-Konfiguration mit Ihren umgebungsspezifischen Details, entweder von Ihrem lokalen Rechner oder über OCI Cloud Shell.
Den vollständigen Terraform-Quellcode können Sie hier herunterladen: oke_terraform_for_beginners.zip. Wir verwenden eine flache Verzeichnisstruktur. Wenn Sie das Package dekomprimieren, stellen Sie sicher, dass sich alle Terraform-Vorlagenquellcodes (.tf, .tfvars, SSH-Schlüssel usw.) im Root-Verzeichnis befinden.
-
Um Terraform anzuweisen, eine der Hauptressourcen (
VCN
,OKE_Cluser
oderNode_Pool
) zu erstellen, müssen Sie das entsprechende Flag (is_vcn_created
,is_k8cluster_created
oderis_pool_created
) in Ihrerterraform.tfvars
auftrue
setzen. Geben Sie dann die verbleibenden Parameter für das Networking, das OKE-Cluster und den Knotenpool in den jeweiligen Codeblöcken an.-
Setzen Sie zunächst
is_vcn_created
auftrue
, um Terraform anzuweisen, ein neues VCN zu erstellen, oderfalse
, um ein vorhandenes VCN zu verwenden (Sie müssen die OCID angeben). Wenn Sie ein neues VCN erstellen, müssen Sie eine CIDR-Blockvariablevcn_cidr_block
angeben. -
Geben Sie die CIDR-Blöcke für die folgenden drei Subnetze an.
- Privates Subnetz des K8-API-Endpunkts (
k8apiendpoint_private_subnet_cidr_block
). - Privates Worker-Knotensubnetz (
workernodes_private_subnet_cidr_block
). - Öffentliches Service-Load-Balancer-Subnetz (
serviceloadbalancers_public_subnet_cidr_block
).
- Privates Subnetz des K8-API-Endpunkts (
-
Setzen Sie das Flag
is_k8cluster_created
, um Terraform anzuweisen, ein Kubernetes-Cluster zu erstellen, und geben Sie das Ziel-Compartment mitcompartment_id
an. Wenn ein Worker-Knotenpool benötigt wird, setzen Sie das Flagis_nodepool_created
entsprechend. -
OKE unterstützt zwei CNI-Typen: VCN-nativ (Standard), bei dem jeder Pod seine eigene IP für bessere Performance und vollständige OCI-Netzwerkintegration erhält, und Flannel-Overlay, ein einfacheres Overlay-Netzwerk, bei dem Pods die VNIC des Knotens gemeinsam verwenden. In diesem Setup ist die
cni_type
aufOCI_VCN_IP_NATIVE
gesetzt, um der Standardclusterkonfiguration zu entsprechen, die vom Workflow Schnellerstellung in der OCI-Konsole erstellt wurde. -
OKE bietet zwei Clustertypen: Basis und Erweitert. Für mehr Flexibilität setzen wir
cluster_type
aufENHANCED_CLUSTER
.- Verbesserte Cluster bieten erweiterte Funktionen wie Add-on-Verwaltung, verbesserte Sicherheit und bessere Lebenszykluskontrolle
- Einfache Cluster bieten eine einfache Kubernetes-Umgebung mit wichtigen Features
-
Knotenzykluskonfiguration
node_cycle_config
definiert, wie Worker-Knoten in einem Knotenpool erstellt, ersetzt oder aktualisiert werden, insbesondere bei Updates, Upgrades oder Autoscaling-Ereignissen. Die Konfiguration definiert die folgenden Attribute:is_node_cycling_enabled (bool):
Aktiviert den automatischen Neustart (Ersatz) von Knoten während einer Aktualisierung oder eines Upgrades. Setzen Sie diesen Wert auf true, um die sichere Knotenrotation zu aktivieren.maximum_surge (int)
: Die maximale Anzahl zusätzlicher Knoten (über die gewünschte Anzahl hinaus), die während Aktualisierungen hinzugefügt werden können. Damit können neue Knoten erstellt werden, bevor alte ohne Ausfallzeit gelöscht werden.maximum_unavailable (int)
: Die Höchstanzahl der Knoten, die während Updates nicht verfügbar sein können. Wird verwendet, um Unterbrechungen bei Rolling-Updates zu kontrollieren.cycle_modes (list)
(optional): Bietet eine geordnete Liste der Aktionen für das erneute Hochfahren von Knoten. Die verfügbaren Zyklusmodi sind:REPLACE_BOOT_VOLUME
: Aktualisiert das Boot-Volume, ohne den Knoten zu beenden.REPLACE_NODES
: Knoten mit aktualisierter Konfiguration abrufen, entladen, beenden und neu erstellen.
-
-
Ändern Sie die Standardwerte nur bei Bedarf. Das Package enthält klare Anweisungen für das Umgebungssetup, die Ausführungsschritte und Schlüsselkonzepte im Zusammenhang mit Networking und Sicherheit.
Im Folgenden finden Sie ein Beispiel für eine Terraform-Konfiguration in der Datei
terraform.tfvars
, die Sie zur Ausführung in Ihrer Umgebung anpassen müssen.########################################################################## # Terraform module: OKE Cluster with Flat Network. # # # # Author: Mahamat H. Guiagoussou and Payal Sharma # # # # Copyright (c) 2025 Oracle # ########################################################################## # Working Compartment compartment_id = "WORKING_COMPARTMENT" #------------------------------------------------------------------------# # Step 2.1: Create Flat Network # #------------------------------------------------------------------------# is_vcn_created = false # Terraform creates VCN if set to 'true' # Display Name Prefix & Host Name Prefix display_name_prefix = "DISPLAY_NAME_PREFIX" # e.g.: "ACME-DEV" host_name_prefix = "HOST_PREFIX" # e.g.: "myvcn" # VCN & Subnets CIDR Blocks vcn_cidr_block = "VCN_CIDR_BLOCK" k8apiendpoint_private_subnet_cidr_block = "ENDPOINT_CIDR_BLOCK" workernodes_private_subnet_cidr_block = "WRKRNODE_CIDR_BLOCK" serviceloadbalancers_public_subnet_cidr_block = "LB_CIDR_BLOCK" #------------------------------------------------------------------------# # Step 2.2: Create the OKE Cluster # #------------------------------------------------------------------------# is_k8cluster_created = false # Terraform creates OKE cluster if 'true' control_plane_kubernetes_version = "K8_VERSION" # e.g.: "v1.32.1" cni_type = "OCI_VCN_IP_NATIVE" # FLANNEL_OVERLAY control_plane_is_public = false # Set the below flag to true for 'OCI_VCN_IP_NATIVE'. This is needed to # provision a dedicated subnet for pods when using the VCN-Native CNI. create_pod_network_subnet = true # NO subnet 'false' image_signing_enabled = false # image not signed cluster_type = "ENHANCED_CLUSTER" # or "BASIC_CLUSTER" #------------------------------------------------------------------------# # Step 2.3: Create a Node Pool for the cluster # #------------------------------------------------------------------------# is_nodepool_created = false # Terraform creates Node_Pool if 'true' worker_nodes_kubernetes_version = "WORKER_NODE_VERSION" # e.g.: "v1.32.1" # Detailed configuration for the Node Pool node_pools = { node_pool_one = { name = "WORKER_NODE_POOL_DISPLAY_NAME" # e.g. "my_worker_node_pool", # https://docs.oracle.com/en-us/iaas/Content/ContEng/Reference/contengimagesshapes.htm shape = "WORKER_NODE_SHAPE_NAME" # e.g.: "VM.Standard.E4.Flex", shape_config = { ocpus = "WORKER_NODE_NB_OF_OCPUS" # e.g.: 1 memory = "WORKER_NODE_MEMOR_SIZE" # e.g.: 16 }, boot_volume_size = "WORKER_BOOT_VOLUME_SIZE" # e.g.: 50 # Oracle maintains a list of supported OKE worker node images here: # https://docs.oracle.com/en-us/iaas/images/oke-worker-node-oracle-linux-8x/ # https://docs.oracle.com/en-us/iaas/Content/ContEng/Reference/contengimagesshapes.htm#images__oke-images image = "WORKER_NODE_OKE_IMAGE" # e.g.: ocid1.image.oc1.iad...." node_labels = { hello = "Demo"}, # Run command "oci iam availability-domain list" to list region's ADs. # No need to set Fault Domains, they are selected automatically availability_domains = ["YOUR_AD_NAME"] # e.g. "GqIF:US-ASHBURN-AD-1", number_of_nodes = "NB_OF_NODES_IN_THE_POOL" # e.g. 1, pv_in_transit_encryption = false, node_cycle_config = { node_cycling_enabled = false maximum_surge = 1 maximum_unavailable = 0 }, ssh_key = "YOUR_SSH_KEY_PATH" # e.g.: "worker_node_ssh_key.pub" } }
-
Führen Sie die folgenden Terraform-Befehle aus.
terraform init terraform validate terraform plan terraform apply
Nach der erfolgreichen Ausführung von
terraform apply
wird das OKE-Cluster in Ihrem Arbeits-Compartment und Ihrer Region mit der folgenden Konfiguration erstellt:- Eine
ENHANCED_CLUSTER
mitOCI_VCN_IP_NATIVE
cni_type
und der angegebenen OKE-Version. - Dedizierte private Subnetze für Worker-Knoten und den API-Endpunkt.
- Ein öffentliches Subnetz für den Load Balancer für den Zugriff auf die Clusterservices.
- Ein verwalteter Knotenpool, der mit der gewünschten Ausprägung, dem gewünschten Image und der gewünschten Knotenanzahl konfiguriert ist.
- Eine
-
Gehen Sie zur OCI-Konsole, um das Cluster-Deployment und die Clusterkonfiguration zu bestätigen.
Die folgenden Bilder veranschaulichen eine erfolgreiche Terraform-Ausführung zusammen mit den generierten Logs.
-
Wenn Sie die Tests abgeschlossen haben, führen Sie
terraform destroy
aus, um die Umgebung zu bereinigen. Mit diesem Befehl werden alle OKE-Ressourcen entfernt, die während des Deployments erstellt wurden, und unnötiger Ressourcenverbrauch in Ihrem Mandanten verhindert.
Aufgabe 2: Terraform-CLI-Ausführung mit Jenkins CI/CD-Pipeline automatisieren
In dieser Aufgabe werden wir die zuvor detaillierten Schritte in vier Hauptphasen abstrahieren, die für eine spätere Orchestrierung durch Jenkins entwickelt wurden. Diese aggregierte Pipeline wird über ein Set von Bash-Skripten implementiert, die Terraform-CLI-Befehle ausführen.
Aufgabe 2.1: Netzwerkressourcen erstellen
Das folgende Skript führt eine Folge mehrerer Terraform-Befehle aus, um die Netzwerkressourcen zu erstellen.
-
Bash-Skript:
create_network_resources.sh
.#!/bin/bash # Change directory to your working directory cd ~/oke_terraform_for_beginners # Run terraform init (at least once) /usr/local/bin/terraform init # Create the OKE Cluster Network resources (VCN, Gateways, RT, K8 API Endpoint Subnet, Worker Node Subnet and LB subnet) /usr/local/bin/terraform apply \ --var is_vcn_created=true \ # Create OKE Cluster Networking Resources --auto-approve
Stellen Sie für die verbleibenden Skripte sicher, dass terraform init
bereits ausgeführt wurde und dass Sie die Befehle aus dem Arbeitsverzeichnis ausführen. Beispiel: ~/oke_terraform_for_beginners
.
Aufgabe 2.2: OKE-Cluster erstellen
Dieses Skript führt den Befehl terraform apply
aus, um das OKE-Cluster zu erstellen.
-
Bash-Skript:
create_oke_cluster.sh
.#!/bin/bash ..... # Create OKE Cluster (auto-approve - not advised for production) /usr/local/bin/terraform apply \ --var is_vcn_created=true \ # Use the created network --var is_k8cluster_created=false \ # Create a new OKE cluster --auto-approve
Aufgabe 2.3. OKE-Worker-Knotenpool erstellen
Das folgende Skript führt den Befehl terraform apply
aus, um den Worker-Knotenpool für das OKE-Cluster zu erstellen.
-
Bash-Skript:
create_worker_node_pool.sh
#!/bin/bash # Create Worker Node Pool (auto-approve - not advised for production) /usr/local/bin/terraform apply \ --var is_vcn_created=true \ # Use the created network --var is_k8cluster_created=true \ # For the existing OKE cluster --var is_nodepool_created=true \ # Create new Worker Node Pool --auto-approve
Aufgabe 2.4: Alle Ressourcen zerstören
Dieses Skript führt einen destroy
-Befehl aus und löscht alle OKE-Clusterressourcen (Netzwerkressourcen, OKE-Cluster und Worker-Knotenpool).
-
Bash-Skript:
destroy_all_cluster_resources.sh
.#!/bin/bash # Run terraform destroy (for testing purposes only, not for production) /usr/local/bin/terraform destroy --auto-approve
Wir haben den End-to-End-Prozess der Jenkins-Pipeline automatisiert und in vier Jenkins-Build-Aufgaben konsolidiert (Aufgabe 2.1, 2.2, 2.3). Diese aggregierte Pipeline wird über Bash-Skripte ausgeführt, die Terraform-CLI-Befehle ausführen. Die Abbildung unten zeigt die Ein-Klick-Automatisierung für die ersten drei Aufgaben. Der Schritt destroy
ist aus Gründen der Einfachheit nicht enthalten.
Aufgabe 3: OKE-Deployments mit Oracle Resource Manager orchestrieren
Oracle Resource Manager-Ablauf (Abbildung):
Im folgenden Diagramm werden die sieben Schritte beschrieben, die Oracle Resource Manager Code Manager veranschaulichen:
- Quellkonfiguration: Definiert, woher die IaC-Konfiguration stammt, wie ein Compartment in OCI, ein OCI Object Storage-Bucket, eine ZIP-Datei, Bitbucket oder GitHub.
- Terraform-Vorlage: Die Infrastrukturkonfiguration wird mit HashiCorp Terraform in einer Vorlagendatei definiert.
- Oracle Resource Manager: Das OCI Terraform as a Service-Angebot übernimmt die Terraform-Vorlage als Eingabe und verwaltet den Infrastruktur-Provisioning-Prozess.
- Stack erstellen: Oracle Resource Manager verwendet die Vorlage, um einen Stack zu erstellen. Dabei handelt es sich um eine Sammlung von OCI-Ressourcen.
- Planen: Bevor Änderungen vorgenommen werden, generiert Oracle Resource Manager einen Plan, in dem die Aktionen beschrieben werden, die zum Provisioning oder Ändern der Infrastruktur ausgeführt werden.
- Anwenden: Basierend auf dem Plan wendet Oracle Resource Manager die Konfiguration an und stellt die angegebenen Ressourcen in OCI bereit.
- Zerstören: Oracle Resource Manager kann auch verwendet werden, um die zuvor vom Stack erstellten Ressourcen zu löschen (deprovisioning durchzuführen) oder zu löschen.
Aufgabe 3.1: Quellkonfiguration: Oracle Resource Manager-Stack definieren
Um ein OKE-Cluster mit Oracle Resource Manager bereitzustellen, laden Sie zunächst das für Anfänger geeignete Modul herunter: oke_terraform_for_beginners_orm.zip
. Wir verwenden eine flache Verzeichnisstruktur. Wenn Sie das Package dekomprimieren, stellen Sie sicher, dass sich alle Terraform-Vorlagenquellcodes (.tf) im Root-Verzeichnis befinden.
Diese Version des Moduls ist für Oracle Resource Manager vorkonfiguriert. terraform.tfvars
wurde entfernt, und alle Variablen werden mit "generischen" Platzhalterwerten wie "REPLACE_WITH_YOUR_OWN_VARIABLE_VALUE" in variables.tf
festgelegt.
Aktualisieren Sie variables.tf
vor dem Erstellen der stack
mit Ihrer Region, Netzwerk-CIDRs und Flags, um die Erstellung des VCN, OKE-Clusters und des Knotenpools zu steuern.
Das OKE-Cluster verwendet VCN-nativen CNI (OCI_VCN_IP_NATIVE
) für Podnetzwerke. Stellen Sie daher sicher, dass das Flag create_pod_network_subnet
aktiviert ist, um die Podsubnetz-CIDRs zu definieren.
Wenn Sie die stack
in der Oracle Resource Manager-UI konfigurieren, können Sie die Erstellung zentraler OKE-Ressourcen steuern, indem Sie Folgendes auswählen:
- VCN: Wählen Sie
is_vcn_created
aus. - OKE-Cluster: Wählen Sie
is_k8cluster_created
aus. - OKE-Knotenpool: Wählen Sie
is_nodepool_created
aus.
Aufgabe 3.2: Oracle Resource Manager-Stack erstellen
Wählen Sie während der stack
-Erstellung die bereitgestellte Terraform-Vorlage aus, und konfigurieren Sie die erforderlichen Variablen direkt in der Konsole. Oracle Resource Manager erkennt automatisch die in den Terraform-Dateien definierten Eingabevariablen und zeigt sie in einer leicht zu bearbeitenden Form an. In dieser Phase müssen Sie umgebungsspezifische Details wie die Mandanten-OCID, die Compartment-OCID und andere erforderliche Werte angeben.
Die folgenden Bilder veranschaulichen den Erstellungs- und Variablenkonfigurationsprozess stack
in der Oracle Cloud-Konsole.
Aufgabe 3.3: Apply-Job ausführen
Der Einfachheit halber überspringen wir den Schritt Plan
, da Apply
in Oracle Resource Manager automatisch ausgeführt wird. Wenn Sie den Job Apply
starten, verwendet Oracle Resource Manager die im vorherigen Schritt Source Configuration
definierte Konfiguration, um die angegebenen OKE-Ressourcen in OCI bereitzustellen.
Die folgenden Bilder veranschaulichen eine erfolgreiche Ausführung des stack Apply
-Jobs zusammen mit den generierten Logs.
Aufgabe 3.4: Zerstörungsjob ausführen
Nachdem Ihre Aktivität oder Ihr Test abgeschlossen ist, können Sie den Job Destroy
in Oracle Resource Manager ausführen, um die Umgebung zu bereinigen. Mit dieser Aktion wird Oracle Resource Manager angewiesen, alle Infrastrukturressourcen, die zuvor als Teil des Stacks erstellt wurden, zu deprovisionieren (löschen), einschließlich OKE-Cluster, Knotenpools, Netzwerkkomponenten und aller zugehörigen Services. Durch die Ausführung von Destroy
wird sichergestellt, dass nicht verwendete Ressourcen vollständig entfernt werden. So können Sie unnötige Kosten vermeiden und einen sauberen OCI-Mandanten aufrechterhalten.
Nächste Schritte
Die Verwendung von Terraform zum Provisioning eines OKE-Clusters bietet einen konsistenten, wiederholbaren und automatisierten Ansatz zur Verwaltung der Kubernetes-Infrastruktur auf Oracle Cloud Infrastructure (OCI). Mit Infrastructure-as-Code (IaC) können Teams die Clustererstellung orchestrieren, Best Practices durchsetzen und CI/CD-Workflows in ihre Deployment-Prozesse integrieren. Oracle Resource Manager verbessert dies, indem Terraform-Vorgänge vereinfacht, der Status verwaltet und die Zusammenarbeit innerhalb von OCI ermöglicht wird. Dieses Tutorial dient als einsteigerfreundliche Einführung, und in unserem anstehenden erweiterten Leitfaden behandeln wir anpassbare Module, Automatisierung auf Produktionsniveau, modulare Architekturmuster und vollständige CI/CD-Integration. Bleiben Sie auf dem Laufenden für einen skalierbareren, sichereren und unternehmensgerechteren Ansatz zur Verwaltung von Kubernetes im großen Maßstab.
Verwandte Links
Bestätigungen
- Autoren - Mahamat Guiagoussou (Lead Resident Cloud Architect), Payal Sharma (Senior Resident Cloud Architect)
Weitere Lernressourcen
Sehen Sie sich weitere Übungen zu docs.oracle.com/learn an, oder greifen Sie auf weitere kostenlose Lerninhalte im Oracle Learning YouTube-Kanal zu. Besuchen Sie außerdem education.oracle.com/learning-explorer, um ein Oracle Learning Explorer zu werden.
Die Produktdokumentation finden Sie im Oracle Help Center.
Create Oracle Cloud Infrastructure Kubernetes Engine Cluster using Terraform
G38262-01
Copyright ©2025, Oracle and/or its affiliates.