Imposta il controller di entrata nativo OCI sul motore Kubernetes OCI con nodi virtuali

Introduzione

Questa esercitazione descrive il processo di impostazione del controller di ingresso nativo di Oracle Cloud Infrastructure (OCI) su Oracle Cloud Infrastructure Kubernetes Engine (OKE) con un pool di nodi dei nodi virtuali. I nodi virtuali sono diversi dai normali nodi di lavoro basati su istanze perché sono una soluzione serverless che elimina le istanze di computazione di base. A differenza dei nodi di lavoro tradizionali, che si basano su istanze di virtual machine specifiche, i nodi virtuali si ridimensionano dinamicamente in base alle esigenze dei carichi di lavoro e non richiedono la gestione manuale dell'infrastruttura sottostante. Ciò li rende ideali per carichi di lavoro che richiedono scalabilità automatica e sovraccarico operativo ridotto.

In questa esercitazione, imposteremo il controller di entrata nativo OCI su OKE utilizzando i nodi virtuali. Configurare i criteri di identità del carico di lavoro, abilitare il componente aggiuntivo in entrata e distribuire le risorse in entrata con i file manifesto Kubernetes.

Seguendo questi task, puoi esporre le tue applicazioni e gestire il traffico in entrata utilizzando le funzionalità di OCI Load Balancer, il tutto sfruttando la semplicità operativa dei nodi virtuali. Questa configurazione semplifica la gestione del traffico e supporta i carichi di lavoro di livello produttivo in modo scalabile ed economico.

Obiettivi

Imposta e configura il controller di entrata nativo OCI in OKE per gestire le risorse in entrata in modo efficiente.

Task 1: Crea criterio principal identità carico di lavoro

Prima di abilitare il controller di entrata nativo OCI, creare un criterio del principal di identità del carico di lavoro. I nodi virtuali sono serverless e non utilizzano le istanze di OCI Compute, pertanto richiedono l'identità del carico di lavoro anziché i principal delle istanze. Questo criterio consente al controller di entrata di gestire le risorse nel compartimento.

Andare alla console OCI, andare a Identità e sicurezza, Identità e fare clic su Criteri.
Creare un criterio e immettere il nome del criterio. Per ulteriori informazioni, vedere Creare un criterio utilizzando OCI Console.

Fare clic su Mostra editor manuale e immettere le istruzioni dei criteri riportate di seguito, sostituendo location e cluster-ocid con valori specifici.

Nota:

<location> deve essere sostituito dal compartimento in cui si trovano le risorse.

<cluster-ocid> deve essere sostituito con l'OCID del cluster OKE.

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

Task 2: Abilita add-on del controller di entrata nativo OCI

Una volta implementato il criterio di identità del carico di lavoro richiesto, puoi procedere per abilitare il componente aggiuntivo del controller di entrata nativo OCI per il cluster OKE. Questo componente aggiuntivo consente l'uso di un load balancer OCI per gestire il traffico in entrata in modo efficiente.

Passare al cluster OKE in OCI Console.
Scorrere verso il basso e fare clic su Componenti aggiuntivi.
Nella pagina Componenti aggiuntivi fare clic su Controller di entrata nativo.
Nella pagina Modifica controller di entrata nativo, selezionare Abilita controller di entrata nativo e immettere le seguenti informazioni in Opzione.
- compartmentId: immettere l'OCID del compartimento.
- loadBalancerSubnetId: immettere l'OCID della subnet del load balancer.
- authType: immettere workloadIdentity.
Fare clic su Salva modifiche per applicare le impostazioni.

Nota: questa configurazione è necessaria per i pool di nodi virtuali, come indicato in precedenza, che sono serverless e non supportano l'autenticazione del principal dell'istanza. In questo caso, l'identità del carico di lavoro è il metodo di autenticazione supportato.

Task 3: Distribuzione delle risorse in entrata per abilitare la funzionalità di entrata nativa

In questo task, crea le risorse Kubernetes necessarie per abilitare la funzionalità di entrata utilizzando il controller di entrata nativo OCI. Questi includono IngressClassParameters, IngressClass e l'oggetto Ingress effettivo.

Rivedere lo scopo di ogni risorsa.
- IngressClassParameters: specifica la configurazione OCI, ad esempio OCID del compartimento, subnet e larghezza di banda.
- IngressClass: collega la funzionalità di entrata Kubernetes al controller di entrata di OCI.
- Ingresso: definisce il modo in cui il traffico viene instradato ai servizi.
Sostituire i valori segnaposto in YAML.
- Sostituire <your compartment ocid> con l'OCID compartimento effettivo.
- Sostituire <your load balancer subnet ocid> con l'OCID della subnet del load balancer.

Applicare il manifesto YAML. Salvare il seguente codice YAML in un file, ad esempio 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

Eseguire il comando seguente per applicare il file manifesto.
```
kubectl apply -f native-ingress.yaml
```

Verificare la creazione della risorsa.

kubectl get ingressclassparameters
kubectl get ingressclass
kubectl get ingress

Task 4: Test del load balancer del controller di entrata nativo OCI

Nota: assicurarsi che le porte necessarie (ad esempio, 80 e/o 443) siano aperte nella lista di sicurezza della VCN e/o nel gruppo di sicurezza di rete (NSG) prima di eseguire il test dell'indirizzo IP del load balancer OCI.

Per verificare che il controller di entrata nativo OCI funzioni correttamente, effettuare le operazioni riportate di seguito.

Usare kubectl per recuperare l'indirizzo IP della risorsa in entrata.
```
kubectl get ingress
```
Copiare l'indirizzo IP mostrato nell'output.
Aprire il browser Web e incollare l'indirizzo IP nella barra degli indirizzi.
Se l'impostazione è corretta, è necessario visualizzare la risposta predefinita del servizio distribuito.

Puoi anche verificare che il load balancer OCI sia stato creato correttamente nella console OCI passando al menu di navigazione, selezionare Networking e fare clic su Load balancer.

Passi successivi

Questa esercitazione consente di configurare correttamente il controller di entrata nativo in OKE utilizzando i nodi virtuali. Questa impostazione ti consente di gestire il traffico in entrata con il servizio OCI Load Balancer, sfruttando al contempo la scalabilità e la semplicità di un ambiente Kubernetes serverless. Ora sei pronto per distribuire carichi di lavoro di livello produttivo con una gestione del traffico semplificata e un sovraccarico minimo dell'infrastruttura.

Conferme

Autore: JP Santana (Master Cloud Architect)

Altre risorse di apprendimento

Esplora altri laboratori su docs.oracle.com/learn o accedi a più contenuti di formazione gratuiti sul canale YouTube di Oracle Learning. Inoltre, visitare education.oracle.com/learning-explorer per diventare Oracle Learning Explorer.

Per la documentazione del prodotto, visitare Oracle Help Center.

Titolo e informazioni sul copyright

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

G34286-03