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.

OKEArchitecture

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:
- Oracle Cloud Shell
- Oracle Befehlszeilenschnittstelle (CLI),
- Oracle Ressourcenmanager,
- Visual Studio Code

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 oder Node_Pool) zu erstellen, müssen Sie das entsprechende Flag (is_vcn_created, is_k8cluster_created oder is_pool_created) in Ihrer terraform.tfvars auf true setzen. Geben Sie dann die verbleibenden Parameter für das Networking, das OKE-Cluster und den Knotenpool in den jeweiligen Codeblöcken an.
1. Setzen Sie zunächst is_vcn_created auf true, um Terraform anzuweisen, ein neues VCN zu erstellen, oder false, um ein vorhandenes VCN zu verwenden (Sie müssen die OCID angeben). Wenn Sie ein neues VCN erstellen, müssen Sie eine CIDR-Blockvariable vcn_cidr_block angeben.
2. 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).
3. Setzen Sie das Flag is_k8cluster_created, um Terraform anzuweisen, ein Kubernetes-Cluster zu erstellen, und geben Sie das Ziel-Compartment mit compartment_id an. Wenn ein Worker-Knotenpool benötigt wird, setzen Sie das Flag is_nodepool_created entsprechend.
4. 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 auf OCI_VCN_IP_NATIVE gesetzt, um der Standardclusterkonfiguration zu entsprechen, die vom Workflow Schnellerstellung in der OCI-Konsole erstellt wurde.
5. OKE bietet zwei Clustertypen: Basis und Erweitert. Für mehr Flexibilität setzen wir cluster_type auf ENHANCED_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
6. 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 mit OCI_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.
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.

OKEArchitecture

Aufgabe 3: OKE-Deployments mit Oracle Resource Manager orchestrieren

Oracle Resource Manager-Ablauf (Abbildung):

OKEArchitecture

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.

OKEArchitecture

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.

OKEArchitecture

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.

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.

Titel und Copyright-Informationen

Create Oracle Cloud Infrastructure Kubernetes Engine Cluster using Terraform

G38262-01

Oracle Cloud Infrastructure Kubernetes Engine-Cluster mit Terraform erstellen

Einführung

Architektur

Ziele

Voraussetzungen

Terraform-Automatisierung für das Erstellen von OKE-Clustern

Aufgabe 1: OKE-Ressourcen mit Terraform bereitstellen (Community Edition)

Aufgabe 2: Terraform-CLI-Ausführung mit Jenkins CI/CD-Pipeline automatisieren

Aufgabe 2.1: Netzwerkressourcen erstellen

Aufgabe 2.2: OKE-Cluster erstellen

Aufgabe 2.3. OKE-Worker-Knotenpool erstellen

Aufgabe 2.4: Alle Ressourcen zerstören

Aufgabe 3: OKE-Deployments mit Oracle Resource Manager orchestrieren

Aufgabe 3.1: Quellkonfiguration: Oracle Resource Manager-Stack definieren

Aufgabe 3.2: Oracle Resource Manager-Stack erstellen

Aufgabe 3.3: Apply-Job ausführen

Aufgabe 3.4: Zerstörungsjob ausführen

Nächste Schritte

Verwandte Links

Bestätigungen

Weitere Lernressourcen