OCI Native Ingress Controller auf OCI Kubernetes Engine mit virtuellen Knoten einrichten

Einführung

In diesem Tutorial wird der Prozess zum Einrichten des nativen Ingress-Controllers von Oracle Cloud Infrastructure (OCI) auf Oracle Cloud Infrastructure Kubernetes Engine (OKE) mit einem Knotenpool für virtuelle Knoten erläutert. Virtuelle Knoten unterscheiden sich von regulären instanzbasierten Worker-Knoten, da sie eine serverlose Lösung sind, die zugrunde liegende Compute-Instanzen abstrahiert. Im Gegensatz zu herkömmlichen Worker-Knoten, die auf bestimmten VM-Instanzen basieren, skalieren virtuelle Knoten dynamisch basierend auf Workload-Anforderungen und erfordern keine manuelle Verwaltung der zugrunde liegenden Infrastruktur. Dies macht sie ideal für Workloads, die eine automatische Skalierung und einen geringeren Betriebsaufwand benötigen.

In diesem Tutorial richten wir den nativen OCI-Ingress-Controller auf OKE mit virtuellen Knoten ein. Wir konfigurieren Workload-Identitäts-Policys, aktivieren das Ingress-Add-on und stellen Ingress-Ressourcen mit Kubernetes-Manifesten bereit.

Durch die Befolgung dieser Aufgaben können Sie Ihre Anwendungen bereitstellen und Ingress-Traffic mit OCI Load Balancer-Funktionen verwalten, während Sie gleichzeitig die betriebliche Einfachheit virtueller Knoten nutzen. Dieses Setup optimiert das Trafficmanagement und unterstützt Workloads der Produktionsklasse auf skalierbare, kosteneffiziente Weise.

Ziele

Richten Sie den nativen OCI-Ingress-Controller in OKE ein, und konfigurieren Sie ihn, um Ingress-Ressourcen effizient zu verwalten.

Aufgabe 1: Workload Identity Principal Policy erstellen

Bevor Sie den nativen OCI-Ingress-Controller aktivieren, erstellen Sie eine Identitäts-Principal-Policy der Workload. Virtuelle Knoten sind serverlos und verwenden keine OCI Compute-Instanzen. Daher benötigen sie eine Workload-Identität anstelle von Instanz-Principals. Mit dieser Policy kann der Ingress-Controller Ressourcen in Ihrem Compartment verwalten.

Navigieren Sie zur OCI-Konsole, navigieren Sie zu Identität und Sicherheit, Identität, und klicken Sie auf Policys.
Erstellen Sie eine Policy, und geben Sie einen Policy-Namen ein. Weitere Informationen finden Sie unter Policy mit der OCI-Konsole erstellen.

Klicken Sie auf Manuellen Editor anzeigen, und geben Sie die folgenden Policy-Anweisungen ein. Dabei werden location und cluster-ocid durch Ihre spezifischen Werte ersetzt.

Hinweis:

<location> muss durch das Compartment ersetzt werden, in dem sich Ihre Ressourcen befinden.

<cluster-ocid> muss durch die OCID des OKE-Clusters ersetzt werden.

Allow any-user to manage load-balancers in <location> where all {request.principal.type = 'workload', request.principal.namespace = 'native-ingress-controller-system', request.principal.service_account = 'oci-native-ingress-controller', request.principal.cluster_id = '<cluster-ocid>'}

Allow any-user to use virtual-network-family in <location> where all {request.principal.type = 'workload', request.principal.namespace = 'native-ingress-controller-system', request.principal.service_account = 'oci-native-ingress-controller', request.principal.cluster_id = '<cluster-ocid>'}

Allow any-user to manage cabundles in <location> where all {request.principal.type = 'workload', request.principal.namespace = 'native-ingress-controller-system', request.principal.service_account = 'oci-native-ingress-controller', request.principal.cluster_id = '<cluster-ocid>'}

Allow any-user to manage cabundle-associations in <location> where all {request.principal.type = 'workload', request.principal.namespace = 'native-ingress-controller-system', request.principal.service_account = 'oci-native-ingress-controller', request.principal.cluster_id = '<cluster-ocid>'}

Allow any-user to manage leaf-certificates in <location> where all {request.principal.type = 'workload', request.principal.namespace = 'native-ingress-controller-system', request.principal.service_account = 'oci-native-ingress-controller', request.principal.cluster_id = '<cluster-ocid>'}

Allow any-user to read leaf-certificate-bundles in <location> where all {request.principal.type = 'workload', request.principal.namespace = 'native-ingress-controller-system', request.principal.service_account = 'oci-native-ingress-controller', request.principal.cluster_id = '<cluster-ocid>'}

Allow any-user to manage leaf-certificate-versions in <location> where all {request.principal.type = 'workload', request.principal.namespace = 'native-ingress-controller-system', request.principal.service_account = 'oci-native-ingress-controller', request.principal.cluster_id = '<cluster-ocid>'}

Allow any-user to manage certificate-associations in <location> where all {request.principal.type = 'workload', request.principal.namespace = 'native-ingress-controller-system', request.principal.service_account = 'oci-native-ingress-controller', request.principal.cluster_id = '<cluster-ocid>'}

Allow any-user to read certificate-authorities in <location> where all {request.principal.type = 'workload', request.principal.namespace = 'native-ingress-controller-system', request.principal.service_account = 'oci-native-ingress-controller', request.principal.cluster_id = '<cluster-ocid>'}

Allow any-user to manage certificate-authority-associations in <location> where all {request.principal.type = 'workload', request.principal.namespace = 'native-ingress-controller-system', request.principal.service_account = 'oci-native-ingress-controller', request.principal.cluster_id = '<cluster-ocid>'}

Allow any-user to read certificate-authority-bundles in <location> where all {request.principal.type = 'workload', request.principal.namespace = 'native-ingress-controller-system', request.principal.service_account = 'oci-native-ingress-controller', request.principal.cluster_id = '<cluster-ocid>'}

Allow any-user to read public-ips in <location> where all {request.principal.type = 'workload', request.principal.namespace = 'native-ingress-controller-system', request.principal.service_account = 'oci-native-ingress-controller', request.principal.cluster_id = '<cluster-ocid>'}

Allow any-user to manage floating-ips in <location> where all {request.principal.type = 'workload', request.principal.namespace = 'native-ingress-controller-system', request.principal.service_account = 'oci-native-ingress-controller', request.principal.cluster_id = '<cluster-ocid>'}

Allow any-user to manage waf-family in <location> where all {request.principal.type = 'workload', request.principal.namespace = 'native-ingress-controller-system', request.principal.service_account = 'oci-native-ingress-controller', request.principal.cluster_id = '<cluster-ocid>'}

Allow any-user to read cluster-family in <location> where all {request.principal.type = 'workload', request.principal.namespace = 'native-ingress-controller-system', request.principal.service_account = 'oci-native-ingress-controller', request.principal.cluster_id = '<cluster-ocid>'}

Allow any-user to use tag-namespaces in <location> where all {request.principal.type = 'workload', request.principal.namespace = 'native-ingress-controller-system', request.principal.service_account = 'oci-native-ingress-controller', request.principal.cluster_id = '<cluster-ocid>'}

Aufgabe 2: OCI Native Ingress Controller-Add-on aktivieren

Sobald die erforderliche Identitäts-Principal-Policy der Workload vorhanden ist, können Sie das native OCI-Ingress-Controller-Add-on für Ihr OKE-Cluster aktivieren. Mit diesem Add-on kann ein OCI Load Balancer Ingress-Traffic effizient verwalten.

Navigieren Sie in der OCI-Konsole zu Ihrem OKE-Cluster.
Blättern Sie nach unten, und klicken Sie auf Add-ons.
Klicken Sie auf der Seite Add-ons auf Nativer Ingress-Controller.
Wählen Sie auf der Seite Nativen Ingress-Controller bearbeiten die Option Nativen Ingress-Controller aktivieren aus, und geben Sie unter Option die folgenden Informationen ein.
- compartmentId: Geben Sie die Compartment-OCID ein.
- loadBalancerSubnetId: Geben Sie die Load-Balancer-Subnetz-OCID ein.
- authType: Geben Sie workloadIdentity ein.
Klicken Sie auf Änderungen speichern, um die Einstellungen anzuwenden.

Hinweis: Diese Konfiguration ist für virtuelle Knotenpools erforderlich, wie bereits erwähnt, sie sind serverlos und unterstützen keine Instanz-Principal-Authentifizierung. Die Workload-Identität ist in diesem Fall die unterstützte Authentifizierungsmethode.

Aufgabe 3: Ingress-Ressourcen bereitstellen, um native Ingress-Funktionalität zu aktivieren

Erstellen Sie in dieser Aufgabe die erforderlichen Kubernetes-Ressourcen, um die Ingress-Funktionalität mit dem nativen OCI-Ingress-Controller zu aktivieren. Dazu gehören die Objekte IngressClassParameters, IngressClass und Ingress.

Prüfen Sie den Zweck der einzelnen Ressourcen.
- IngressClassParameters: Gibt eine OCI-spezifische Konfiguration an, wie Compartment-OCID, Subnetz und Bandbreite.
- IngressClass: Verknüpft die Kubernetes-Ingress-Funktionalität mit dem Ingress-Controller von OCI.
- Ingress: Definiert, wie Traffic an Ihre Services weitergeleitet wird.
Platzhalterwerte in YAML ersetzen.
- Ersetzen Sie <your compartment ocid> durch die tatsächliche Compartment-OCID.
- Ersetzen Sie <your load balancer subnet ocid> durch die OCID Ihres Load Balancer-Subnetzes.

Wenden Sie das YAML-Manifest an. Speichern Sie den folgenden YAML-Code in einer Datei. Beispiel: native-ingress.yaml.

apiVersion: apps/v1
kind: Deployment
metadata:
  name: test-web-app
  namespace: default
spec:
  replicas: 2
  selector:
    matchLabels:
      app: test-web
  template:
    metadata:
      labels:
        app: test-web
    spec:
      containers:
      - name: nginx
        image: nginx:latest
        ports:
        - containerPort: 80
        readinessProbe:
          httpGet:
            path: /
            port: 80
          initialDelaySeconds: 3
          periodSeconds: 5
        resources:
          requests:
            cpu: "100m"
            memory: "128Mi"
          limits:
            cpu: "500m"
            memory: "256Mi"

apiVersion: v1
kind: Service
metadata:
  name: test-web-service
  namespace: default
spec:
  selector:
    app: test-web
  ports:
    - protocol: TCP
      port: 80
      targetPort: 80

apiVersion: ingress.oraclecloud.com/v1beta1
kind: IngressClassParameters
metadata:
  name: native-ic-params
  namespace: native-ingress-controller-system
spec:
  compartmentId: "ocid1.compartment.oc1..aaaaaaaa2eimxxxxxxxxxxz4lkcety52hfdg6wdoff6744yn4hrshofla"
  subnetId: "ocid1.subnet.oc1.iad.aaaaaaaaa72ie4xxxxxxxxxrxxrly6nmkb77qxt6mi2t5pvrdhge32q"
  loadBalancerName: "test-web-ingress"
  isPrivate: false
  maxBandwidthMbps: 400
  minBandwidthMbps: 100

apiVersion: networking.k8s.io/v1
kind: IngressClass
metadata:
  name: native-ic-ingress-class
  annotations:
    ingressclass.kubernetes.io/is-default-class: "true"
spec:
  controller: oci.oraclecloud.com/native-ingress-controller
  parameters:
    apiGroup: ingress.oraclecloud.com
    kind: IngressClassParameters
    name: native-ic-params
    scope: Namespace
    namespace: native-ingress-controller-system

apiVersion: networking.k8s.io/v1
kind: Ingress
metadata:
  name: test-web-ingress-quickstart
  namespace: default
  annotations:
    oci.oraclecloud.com/load-balancer-type: "lb"
    oci.oraclecloud.com/healthcheck-protocol: "HTTP"
    oci.oraclecloud.com/healthcheck-port: "80"
    oci.oraclecloud.com/healthcheck-path: "/"
    oci.oraclecloud.com/healthcheck-return-code: "200"
spec:
  ingressClassName: native-ic-ingress-class
  rules:
  - host: test.example.com
    http:
      paths:
      - path: /
        pathType: Prefix
        backend:
          service:
            name: test-web-service
            port:
              number: 80
  - http:
      paths:
      - path: /
        pathType: Prefix
        backend:
          service:
            name: test-web-service
            port:
              number: 80

Führen Sie den folgenden Befehl aus, um das Manifest anzuwenden.
```
kubectl apply -f native-ingress.yaml
```

Prüfen Sie die Ressourcenerstellung.

kubectl get ingressclassparameters
kubectl get ingressclass
kubectl get ingress

Aufgabe 4: OCI Native Ingress Controller Load Balancer testen

Hinweis: Stellen Sie sicher, dass die erforderlichen Ports (z.B. 80 und/oder 443) in Ihrer VCN-Sicherheitsliste und/oder Netzwerksicherheitsgruppe (NSG) geöffnet sind, bevor Sie die OCI-Load-Balancer-IP-Adresse testen.

Um zu prüfen, ob der native OCI-Ingress-Controller ordnungsgemäß funktioniert, führen Sie die folgenden Schritte aus:

Verwenden Sie kubectl, um die IP-Adresse der Ingress-Ressource abzurufen.
```
kubectl get ingress
```
Kopieren Sie die in der Ausgabe angezeigte IP-Adresse.
Öffnen Sie Ihren Webbrowser und fügen Sie die IP-Adresse in die Adressleiste ein.
Wenn Ihr Setup korrekt ist, sollte die Standardantwort vom bereitgestellten Service angezeigt werden.

Sie können auch prüfen, ob der OCI Load Balancer ordnungsgemäß in der OCI-Konsole erstellt wurde. Navigieren Sie dazu zum Navigationsmenü, wählen Sie Networking aus, und klicken Sie auf Load Balancer.

Nächste Schritte

Mit diesem Tutorial haben Sie den nativen Ingress-Controller auf OKE erfolgreich mit virtuellen Knoten konfiguriert. Mit diesem Setup können Sie Ingress-Traffic mit dem OCI Load Balancer-Service verwalten und gleichzeitig von der Skalierbarkeit und Einfachheit einer serverlosen Kubernetes-Umgebung profitieren. Sie können jetzt Workloads der Produktionsklasse mit optimiertem Trafficmanagement und minimalem Infrastrukturaufwand bereitstellen.

Bestätigungen

Autor – JP Santana (Master 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

Set Up the OCI Native Ingress Controller on OCI Kubernetes Engine with Virtual Nodes

G34282-03