Nota:

Questa esercitazione è disponibile in un ambiente di laboratorio gratuito fornito da Oracle.
Utilizza valori di esempio per le credenziali, la tenancy e i compartimenti di Oracle Cloud Infrastructure. Al termine del laboratorio, sostituire questi valori con quelli specifici del proprio ambiente cloud.

Utilizza OCI Cloud Controller Manager in Oracle Cloud Native Environment

Introduzione

Il servizio Kubernetes LoadBalancer espone la distribuzione esternamente utilizzando il load balancer di un provider cloud. I servizi NodePort e ClusterIP dipendenti, ai quali vengono creati automaticamente gli instradamenti del load balancer esterno.

Questa esercitazione mostra come distribuire il modulo Oracle Cloud Infrastructure Cloud Controller Manager (modulo OCI-CCM) all'interno di Oracle Cloud Native Environment per gestire le richieste di un tipo di servizio LoadBalancer esterno. Il modulo Oracle Cloud Infrastructure Cloud Controller Manager utilizza il progetto oci-cloud-controller-manager open source, che è un'implementazione di Kubernetes Cloud Controller Manager (o provider cloud out-of-tree) per Oracle Cloud Infrastructure (OCI).

Obiettivi

Distribuire il modulo Oracle Cloud Infrastructure Cloud Controller Manager
Creare una distribuzione e un servizio LoadBalancer
Verificare l'accesso tramite il servizio LoadBalancer

Prerequisiti

Un sistema Oracle Linux 8 o versione successiva con la seguente configurazione:

un utente non root con privilegi sudo
Oracle Cloud Native Environment installato e configurato

Configura laboratorio

Nota: quando si utilizza l'ambiente di laboratorio gratuito, vedere Oracle Linux Lab Basics per informazioni sulla connessione e altre istruzioni sull'uso.

Informazioni: l'ambiente di laboratorio gratuito distribuisce un Oracle Cloud Native Environment compatto sul nodo fornito, pronto per la creazione di ambienti. Il completamento di questa distribuzione richiede circa 8-10 minuti dopo l'avvio. Pertanto, potrebbe essere necessario uscire durante l'esecuzione e quindi tornare a completare il laboratorio.

Se non è già connesso, aprire un terminale e connettersi tramite ssh al sistema ocne-node01.
```
ssh oracle@<ip_address_of_ol_node>
```

Verificare che l'ambiente sia pronto.

kubectl get pods -A

Output di esempio:

[oracle@ocne-node01 ~]$ kubectl get pods -A
NAMESPACE                      NAME                                             READY   STATUS    RESTARTS   AGE
externalip-validation-system   externalip-validation-webhook-7988bff847-8ws2v   1/1     Running   0          3m18s
kube-system                    coredns-7cbc77dbc7-qxqth                         1/1     Running   0          3m18s
kube-system                    coredns-7cbc77dbc7-r9bgj                         1/1     Running   0          3m18s
kube-system                    etcd-ocne-node01                                 1/1     Running   0          3m37s
kube-system                    kube-apiserver-ocne-node01                       1/1     Running   0          3m37s
kube-system                    kube-controller-manager-ocne-node01              1/1     Running   0          3m37s
kube-system                    kube-flannel-ds-vcwzn                            1/1     Running   0          3m18s
kube-system                    kube-proxy-7lx59                                 1/1     Running   0          3m18s
kube-system                    kube-scheduler-ocne-node01                       1/1     Running   0          3m37s
kubernetes-dashboard           kubernetes-dashboard-5d5d4947b5-7pffh            1/1     Running   0          3m18s

Porta HealthCheck aperta su firewall Oracle Linux

Quando si utilizza un servizio LoadBalancer associato a OCI-CCM, Kubernetes prevede un endpoint di controllo dello stato disponibile sulla porta 10256. Pertanto, kube-proxy crea un listener su questa porta in modo che il load balancer del provider cloud possa verificare che kube-proxy sia integro. Questo controllo dello stato indica il modo in cui il load balancer determina quali nodi possono disporre di traffico instradato verso di loro.

Impostare le regole firewall per il nodo.
```
sudo firewall-cmd --add-port=10256/tcp --permanent
sudo firewall-cmd --reload
```
Quando si lavora in un ambiente in cluster, aprire questa porta firewall su tutti i nodi del piano di controllo e di lavoro.

Distribuisci il modulo Oracle Cloud Infrastructure Cloud Controller Manager

Aggiungere i moduli helm e oci-ccm al file di configurazione esistente.
```
tee -a ~/myenvironment.yaml > /dev/null << 'EOF'
      - module: helm
        name: myhelm
        args:
          helm-kubernetes-module: mycluster
      - module: oci-ccm
        name: myoci
        oci-ccm-helm-module: myhelm
        oci-use-instance-principals: true
        oci-compartment:
        oci-vcn:
        oci-lb-subnet1:
EOF
```
L'ambiente di laboratorio gratuito utilizza criteri per consentire l'uso dei principal delle istanze, che consentono alle istanze di essere attori (o principal) autorizzati a eseguire azioni sulle risorse del servizio.

Il modulo Oracle Cloud Infrastructure Cloud Controller Manager utilizza l'opzione oci-use-instance-principals: true per l'autenticazione come impostazione predefinita.

Per ulteriori dettagli, consulta la documentazione relativa all'uso del load balancer Oracle Cloud Infrastructure su come passare le informazioni sulle credenziali relative alla tenancy Oracle Cloud Infrastructure anziché utilizzare i principal delle istanze.
Aggiungere gli OCID richiesti nel file di configurazione.
1. Passare dal Terminal al desktop del laboratorio gratuito.
2. Aprire la pagina dei dettagli di Luna Lab utilizzando l'icona Luna Lab dal desktop del laboratorio gratuito.
3. Fare clic sulla scheda Oracle Cloud.
4. Scorrere verso il basso, individuare l'OCID compartimento e copiarlo.
5. Passare al terminale precedente aperto.
6. Aprire il file di configurazione usando l'editor di testo preferito. Qui useremo vi.
```
vi ~/myenvironment.yaml
```
7. Immettere la modalità di inserimento vi digitando i.
8. Aggiungere l'OCID compartimento alla fine della riga oci-compartment:.
  
  Nota: poiché si tratta di YAML, ricordare di aggiungere uno spazio prima di incollare il valore.
  Esempio:
  - module: oci-ccm name: myoci oci-ccm-helm-module: myhelm oci-use-instance-principals: true oci-compartment: ocid1.compartment.oc1..aaaaaaaamqicnhi7e6dj7fwtbiibfxxlzjpd3uf33f7a33gftzgpchrnuzna oci-vcn: oci-lb-subnet1:
9. Passare alla pagina dei dettagli di Luna Lab e fare clic sulla scheda Risorse.
10. Trovare l'indirizzo vcn_ocid e copiarlo.
11. Tornare al terminale.
12. Aggiungere il valore vcn_ocid alla fine della riga oci-vcn:.
  
  Nota: poiché si tratta di YAML, ricordare di aggiungere uno spazio prima di incollare il valore.
  Esempio:
  - module: oci-ccm name: myoci oci-ccm-helm-module: myhelm oci-use-instance-principals: true oci-compartment: ocid1.compartment.oc1..aaaaaaaamqicnhi7e6dj7fwtbiibfxxlzjpd3uf33f7a33gftzgpchrnuzna oci-vcn: ocid1.vcn.oc1.eu-frankfurt-1.amaaaaaar5cqh7qam56nztotyx4xzhovuo7stl5dddlmdmubdcdam64sadka oci-lb-subnet1:
13. Tornare alla pagina dei dettagli di Luna Lab.
14. Trovare l'indirizzo vcn_subnet_ocid e copiarlo.
15. Tornare al terminale.
16. Aggiungere vcn_subnet_ocid alla fine della riga oci-lb-subnet1:.
  
  Nota: poiché si tratta di YAML, ricordare di aggiungere uno spazio prima di incollare il valore.
  Esempio:
  - module: oci-ccm name: myoci oci-ccm-helm-module: myhelm oci-use-instance-principals: true oci-compartment: ocid1.compartment.oc1..aaaaaaaamqicnhi7e6dj7fwtbiibfxxlzjpd3uf33f7a33gftzgpchrnuzna oci-vcn: ocid1.vcn.oc1.eu-frankfurt-1.amaaaaaar5cqh7qam56nztotyx4xzhovuo7stl5dddlmdmubdcdam64sadka oci-lb-subnet1: ocid1.subnet.oc1.eu-frankfurt-1.aaaaaaaazq3yaeofyv3azmnzm2cxrilnfhpmvhark7xw5u6eo3574mtbzswa
17. Salvare e chiudere il file. Se si utilizza vi, è possibile farlo digitando ESC, :wq! e ENTER.
IMPORTANTE: assicurarsi che gli OCID siano corretti in base all'ambiente in uso. Se i valori non sono corretti, viene installato il modulo oci-ccm, ma non sarà possibile creare un modulo LoadBalancer quando richiesto dal servizio.

Creare e installare moduli.

olcnectl module create --config-file myenvironment.yaml
olcnectl module validate --config-file myenvironment.yaml
olcnectl module install --config-file myenvironment.yaml

Creare la distribuzione e il servizio

Genera il file di configurazione per la distribuzione e il servizio.

tee echo-oci-lb.yml > /dev/null << 'EOF'
---
apiVersion: apps/v1
kind: Deployment
metadata:
  name: echo-deployment
  labels:
    app: echo1
spec:
  replicas: 2
  selector:
    matchLabels:
      app: echo1
  template:
    metadata:
      labels:
        app: echo1
    spec:
      containers:
      - name: echoserver
        image: k8s.gcr.io/echoserver:1.4
        ports:
        - containerPort: 80
---
kind: Service
apiVersion: v1
metadata:
  name: echo-lb-service
  annotations:
    service.beta.kubernetes.io/oci-load-balancer-security-list-management-mode: "None"
    service.beta.kubernetes.io/oci-load-balancer-internal: "false"
    service.beta.kubernetes.io/oci-load-balancer-shape: "10Mbps"
spec:
  selector:
    app: echo1
  type: LoadBalancer
  ports:
  - name: http
    port: 80
    targetPort: 8080
EOF

Creare la distribuzione e il servizio.
```
kubectl create -f echo-oci-lb.yml
```

Verifica creazione distribuzione e servizio

Recupera una lista di distribuzioni.

kubectl get deployment

Output di esempio:

NAME              READY   UP-TO-DATE   AVAILABLE   AGE
echo-deployment   2/2     2            2           15s

Recupera una lista di servizi.
```
kubectl get service
```
Output di esempio:
```
NAME              TYPE           CLUSTER-IP     EXTERNAL-IP   PORT(S)        AGE
echo-lb-service   LoadBalancer   10.108.35.18   <pending>     80:32162/TCP   23s
kubernetes        ClusterIP      10.96.0.1      <none>        443/TCP        13m
```
Il comando 'pending' in EXTERNAL-IP per echo-lb-service esiste finché il modulo Oracle Cloud Infrastructure Cloud Controller Manager non crea e avvia OCI LoadBalancer.

Ripetere l'esecuzione del comando kubectl get service finché l'output non mostra l'indirizzo EXTERNAL-IP. Dovrebbe apparire entro 1-2 minuti, al massimo.

Le PORTS indicano la porta di ascolto LoadBalancer OCI (80) e la porta di servizio secondaria NodePort Kubernetes generata automaticamente.
Ottenere una lista di endpoint.
```
kubectl get endpoints
```
Output di esempio:
```
NAME              ENDPOINTS                         AGE
echo-lb-service   10.244.0.7:8080,10.244.0.8:8080   5m37s
kubernetes        10.0.0.140:6443                   18m
```
Un endpoint è una risorsa a cui fa riferimento un servizio Kubernetes. La risorsa tiene traccia degli indirizzi IP e delle porte di uno o più pod assegnati in modo dinamico durante la creazione del servizio.

Verifica applicazione

Test su nodo piano di controllo

Con il tipo di servizio LoadBalancer, l'indirizzo IP e la porta di cui eseguire il test sono l'indirizzo IP esterno e la porta del servizio, che è il listener LoadBalancer OCI. La richiesta viene quindi inviata al backend OCI LoadBalancer. Il backend OCI LoadBalancer instrada quindi il traffico al servizio NodePort secondario in esecuzione sul nodo specifico e poi sul pod.

L'utilizzo di questo test specifico richiede un nodo in cui esiste kubectl.

Utilizzare JSONPath per assegnare una variabile al listener LoadBalancer.

LB=$(kubectl get svc -o jsonpath="{.status.loadBalancer.ingress[0].ip}" echo-lb-service)

Utilizzare JSONPath per assegnare una variabile alla porta LoadBalancer.

LBPORT=$(kubectl get svc -o jsonpath="{.spec.ports[0].port}" echo-lb-service)

Verificare l'applicazione.

curl -i -w "\n" $LB:$LBPORT

Output di esempio:

[oracle@ocne-node01 ~]$ curl -i -w "\n" $LB:$LBPORT
HTTP/1.1 200 OK
Server: nginx/1.10.0
Date: Wed, 06 Jul 2022 16:41:23 GMT
Content-Type: text/plain
Transfer-Encoding: chunked
Connection: keep-alive

CLIENT VALUES:
client_address=10.244.0.1
command=GET
real path=/
query=nil
request_version=1.1
request_uri=http://130.162.210.115:8080/

SERVER VALUES:
server_version=nginx: 1.10.0 - lua: 10001

HEADERS RECEIVED:
accept=*/*
host=10.0.0.138
user-agent=curl/7.61.1
BODY:
-no body in request-

L'indirizzo IP di 130.162.210.115 mostrato nell'output precedente è l'indirizzo IP esterno per l'indirizzo LoadBalancer OCI. Questo indirizzo è diverso su ogni distribuzione del laboratorio. Verificare l'indirizzo del load balancer eseguendo facoltativamente il login alla console cloud e passando a Networking > Load balancer.

loadbalancer_ip

Test da Luna Desktop

L'uso di questo test specifico richiede un nodo esterno al cluster Kubernetes.

Trovare il valore EXTERNAL-IP per echo-lb-service.

kubectl get service

Output di esempio

[oracle@ocne-node01 ~]$ kubectl get service
NAME              TYPE           CLUSTER-IP     EXTERNAL-IP      PORT(S)        AGE
echo-lb-service   LoadBalancer   10.102.1.165   130.162.210.115  80:31468/TCP   32s
kubernetes        ClusterIP      10.96.0.1      <none>           443/TCP        11m

Aprire una nuova scheda utilizzando il browser sul desktop Luna.
Immettere il valore restituito nella colonna EXTERNAL-IP e premere Invio.

NOTA: client_address nell'output è l'indirizzo IP del gateway associato all'interfaccia cni0. L'interfaccia cni0 gestisce la rete cluster Kubernetes descritta nella documentazione a monte Plugin di rete.

Riepilogo

Ora capiamo come creare un servizio LoadBalancer all'interno di Kubernetes. Scopri ed esplora automaticamente le funzionalità aggiuntive di Oracle Cloud Native Environment utilizzando il modulo Oracle Cloud Infrastructure Cloud Controller Manager e le annotazioni del load balancer disponibili.

Per ulteriori informazioni

Altre risorse di apprendimento

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

Per la documentazione sul prodotto, visitare Oracle Help Center.

Titolo e informazioni sul copyright

Use OCI Cloud Controller Manager on Oracle Cloud Native Environment

F60051-02

August 2022