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 tuo ambiente cloud.

Esegui Kubernetes su Oracle Linux

Introduzione

Kubernetes è greco per pilota o elmista - in altre parole, la persona che segue comandi e guida una nave verso il suo obiettivo finale (anziché essere il capitano che dà ordini). A tal fine, Kubernetes è una piattaforma open source estendibile per la distribuzione, la gestione e la scalabilità delle applicazioni gestite in container. Raggiunge questo risultato utilizzando diversi strumenti della riga di comando. In questo laboratorio viene utilizzato uno di quelli denominati kubectl insieme ai file YAML per definire gli attributi richiesti per l'organizzazione che distribuisce l'applicazione e capire come impostare e gestire l'applicazione una volta completata la distribuzione.

Tutte le distribuzioni in un cluster Kubernetes vengono rappresentate come oggetti. Questi oggetti distribuiti utilizzano file YAML basati su testo per fornire i dettagli dello stato richiesto di qualsiasi applicazione distribuita nel cluster. Questi file YAML possono descrivere quanto segue:

Applicazioni in container da eseguire sui nodi
Dettagli delle risorse richieste dall'applicazione
Qualsiasi criterio che descriva in dettaglio la modalità di gestione dello stato di tali applicazioni, ad esempio criteri di riavvio, criteri di aggiornamento e così via.

Questo terzo punto, anche se importante, è complicato senza comprendere le basi. Pertanto, ci fermeremo per ora e gestiremo questo argomento in futuri tutorial.

Questa esercitazione funziona con Kubernetes in esecuzione in un Oracle Cloud Native Environment compatto su Oracle Linux. L'intento non è quello di essere un "sportello unico" per tutto il necessario per amministrare un'installazione di produzione. Presenta invece le competenze necessarie per distribuire un'applicazione campione funzionante.

Obiettivi

Esamina i vari componenti Kubernetes, ad esempio di pod, distribuzione e servizi
Esaminare i diversi oggetti Kubernetes
Distribuisci e sottoponi a test un progetto di esempio

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 ambiente Lab

Nota: quando si utilizza l'ambiente di laboratorio gratuito, vedere Oracle Linux Lab Basics per le connessioni e altre istruzioni d'uso.

Informazioni: l'ambiente di laboratorio gratuito distribuisce Oracle Cloud Native Environment 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 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

Creare una distribuzione su un pod e i dettagli delle richieste

In Kubernetes, deployment è un termine tecnico che si riferisce a un file che disciplina il comportamento e le caratteristiche di un pod. Gli amministratori utilizzano le distribuzioni per indicare all'applicazione cosa fare e Kubernetes esegue il task per raggiungere tale stato.

Gli esempi utilizzano un'immagine che contiene un piccolo server Web nginx che riporta l'IP di origine delle richieste ricevute tramite un'intestazione HTTP.

Creare una distribuzione di echoserver.

kubectl create deployment test --image=k8s.gcr.io/echoserver:1.4

Elencare tutti i pod nel cluster.

kubectl get pods

Output di esempio:

[oracle@ocne-node01 ~]$ kubectl get pods
NAME                    READY   STATUS    RESTARTS   AGE
test-6c486b6d76-467p7   1/1     Running   0          53s

Nota: il nome pod contiene un valore suffisso che varia ogni volta che si distribuisce il pod.

Utilizzare JSONPath per assegnare il nome pod a una variabile.

TESTPOD=$(kubectl get pods -o jsonpath='{ $.items[*].metadata.name }')

Eseguire il test dell'assegnazione della variabile.

Il comando kubectl get pods consente anche di passare un nome pod come parametro per visualizzare solo le informazioni per il pod specifico.
```
kubectl get pods $TESTPOD
```

Richiedi le informazioni selezionate sul pod.

kubectl get pod $TESTPOD --output custom-columns=NAME:metadata.name,NODE_IP:status.hostIP,POD_IP:status.podIP

Output di esempio:

[oracle@ocne-node01 ~]$ kubectl get pod $TESTPOD --output custom-columns=NAME:metadata.name,NODE_IP:status.hostIP,POD_IP:status.podIP
NAME                    NODE_IP      POD_IP
test-6c486b6d76-467p7   10.0.0.140   10.244.0.7

Recupera i dettagli del pod.

kubectl describe pod $TESTPOD

Output di esempio:

[oracle@ocne-node01 ~]$ kubectl describe pod test-6c486b6d76-467p7
Name:         test-6c486b6d76-467p7
Namespace:    default
Priority:     0
Node:         ocne-node01/10.0.0.140
Start Time:   Tue, 28 Jun 2022 19:21:27 +0000
Labels:       app=test
              pod-template-hash=6c486b6d76
Annotations:  <none>
Status:       Running
IP:           10.244.0.7
IPs:
  IP:           10.244.0.7
Controlled By:  ReplicaSet/test-6c486b6d76
Containers:
  echoserver:
    Container ID:   cri-o://5b7866a27722ec0998cd9fe74945fb82b4dd9ed4c5c80671d9e8aa239c7008a4
    Image:          k8s.gcr.io/echoserver:1.4
    Image ID:       k8s.gcr.io/echoserver@sha256:5d99aa1120524c801bc8c1a7077e8f5ec122ba16b6dda1a5d3826057f67b9bcb
    Port:           <none>
    Host Port:      <none>
    State:          Running
      Started:      Tue, 28 Jun 2022 19:21:30 +0000
    Ready:          True
    Restart Count:  0
    Environment:    <none>
    Mounts:
      /var/run/secrets/kubernetes.io/serviceaccount from kube-api-access-d67ph (ro)
Conditions:
  Type              Status
  Initialized       True 
  Ready             True 
  ContainersReady   True 
  PodScheduled      True 
Volumes:
  kube-api-access-d67ph:
    Type:                    Projected (a volume that contains injected data from multiple sources)
    TokenExpirationSeconds:  3607
    ConfigMapName:           kube-root-ca.crt
    ConfigMapOptional:       <nil>
    DownwardAPI:             true
QoS Class:                   BestEffort
Node-Selectors:              <none>
Tolerations:                 node.kubernetes.io/not-ready:NoExecute op=Exists for 300s
                             node.kubernetes.io/unreachable:NoExecute op=Exists for 300s
Events:
  Type    Reason     Age   From               Message
  ----    ------     ----  ----               -------
  Normal  Scheduled  21m   default-scheduler  Successfully assigned default/test-6c486b6d76-467p7 to ocne-node01
  Normal  Pulling    21m   kubelet            Pulling image "k8s.gcr.io/echoserver:1.4"
  Normal  Pulled     21m   kubelet            Successfully pulled image "k8s.gcr.io/echoserver:1.4" in 3.102843235s
  Normal  Created    21m   kubelet            Created container echoserver
  Normal  Started    21m   kubelet            Started container echoserver

Creare una distribuzione con un file YAML

L'uso dei file manifesto di distribuzione Kubernetes definisce come distribuire un'applicazione nel cluster Kubernetes e fornisce l'accesso ad altre funzionalità Kubernetes quali la self-healing, la scalabilità, il controllo delle versioni e gli aggiornamenti in sequenza. Questo laboratorio non affronterà questa funzionalità più complessa fornita in Kubernetes. Viene invece illustrato come utilizzare un file manifesto di base per distribuire un'applicazione.

Un file manifest di distribuzione viene scritto in formato JSON o YAML. Sebbene sia possibile utilizzare JSON, YAML è molto più diffuso a causa della sua flessibilità, leggibilità e capacità di includere commenti descrittivi per chiarire gli aspetti della distribuzione finale.

Quando si esegue una distribuzione, un pod viene aggiornato mediante una serie di aggiornamenti dichiarativi per raggiungere lo stato desiderato per l'applicazione in esecuzione.

Sebbene tutti i dettagli di deployment.yaml siano essenziali per consentire a Kubernetes di attivare la richiesta di distribuzione, in questi casi vengono evidenziati alcuni dei componenti più importanti:

Il campo apiVersion specifica la versione dell'API Kubernetes da utilizzare. Impostare questa opzione su apps/v1 se si utilizza una versione aggiornata di Kubernetes.
In questo caso, il campo kind informa Kubernetes per fare riferimento a un tipo di oggetto denominato Deployment.
La sezione metadati viene utilizzata per descrivere i dettagli del nome della distribuzione e delle etichette associate.
La sezione .spec è probabilmente la sezione più critica di qualsiasi file manifest di distribuzione. Tutto da qui in basso si riferisce alla distribuzione del Pod. Qualsiasi elemento sotto la sezione .spec.template descrive gli usi del modello di pod utilizzato da Kubernetes per gestire la distribuzione (in questo esempio, è un singolo contenitore).
Altri campi non utilizzati in questo esempio sono il campo .spec.replicas (che indica a Kubernetes quante repliche pod distribuire) e il campo .spec.strategy (che indica a Kubernetes come eseguire gli aggiornamenti alla distribuzione).

Per ulteriori informazioni su questi altri campi, consultare la documentazione relativa alle distribuzioni a monte.

Creare il file di distribuzione.

cat << 'EOF' | tee mydeployment.yaml > /dev/null
apiVersion: apps/v1
kind: Deployment
metadata:
 name: echo1
spec:
 selector:
   matchLabels: 
     app: echo1
 template:
   metadata:
     labels:
       app: echo1
   spec:
     containers:
     - name: echoserver
       image: k8s.gcr.io/echoserver:1.4
EOF

Distribuire l'applicazione su un pod utilizzando il file manifest di distribuzione.

kubectl apply -f mydeployment.yaml

Output di esempio:

[[oracle@ocne-node01 ~]$ kubectl apply -f mydeployment.yaml
deployment.apps/echo1 created

Elencare il pod gestito dalla distribuzione.
```
kubectl get pods -l app=echo1
```
Output di esempio:
```
[oracle@ocne-node01 ~]$ kubectl get pods -l app=echo1
NAME                     READY   STATUS    RESTARTS   AGE
echo1-7cbf6dfb96-4cgq7   1/1     Running   0          24s
```
- L'opzione -l o --selector= fornisce un selettore (interrogazione etichetta) su cui applicare il filtro. Questa opzione supporta '=', '==' e '!='.(ad esempio, -l key1=value1,key2=value2)
Nota: promemoria per ricordare che il nome pod contiene un valore suffisso che varia ogni volta che si distribuisce il pod.
Verifica della distribuzione riuscita.
```
kubectl get deploy echo1
```
Output di esempio:
```
[oracle@ocne-node01 ~]$ kubectl get deploy echo1
NAME    READY   UP-TO-DATE   AVAILABLE   AGE
echo1   1/1     1            1           16m
```
- L'opzione deploy è di breve durata per deployments. Il comando kubectl consente di utilizzare una sintassi abbreviata per molte delle relative opzioni. Per ulteriori dettagli, eseguire kubectl --help.

Restituire informazioni più dettagliate per una distribuzione.

kubectl describe deploy echo1

Output di esempio:

[oracle@ocne-node01 ~]$ kubectl describe deploy echo1
Name:                   echo1
Namespace:              default
CreationTimestamp:      Tue, 28 Jun 2022 20:20:40 +0000
Labels:                 <none>
Annotations:            deployment.kubernetes.io/revision: 1
Selector:               app=echo1
Replicas:               1 desired | 1 updated | 1 total | 1 available | 0 unavailable
StrategyType:           RollingUpdate
MinReadySeconds:        0
RollingUpdateStrategy:  25% max unavailable, 25% max surge
Pod Template:
  Labels:  app=echo1
  Containers:
   echoserver:
    Image:        k8s.gcr.io/echoserver:1.4
    Port:         <none>
    Host Port:    <none>
    Environment:  <none>
    Mounts:       <none>
  Volumes:        <none>
Conditions:
  Type           Status  Reason
  ----           ------  ------
  Available      True    MinimumReplicasAvailable
  Progressing    True    NewReplicaSetAvailable
OldReplicaSets:  <none>
NewReplicaSet:   echo1-7cbf6dfb96 (1/1 replicas created)
Events:
  Type    Reason             Age   From                   Message
  ----    ------             ----  ----                   -------
  Normal  ScalingReplicaSet  23m   deployment-controller  Scaled up replica set echo1-7cbf6dfb96 to 1

Utilizza il servizio ClusterIP

Nonostante la corretta distribuzione della echo1 distribuzione in un pod, non è molto utile se gli utenti finali non possono accedervi internamente o in rete. Tale accesso è utile quando un servizio espone una distribuzione alla rete.

Il tipo di servizio Kubernetes predefinito è ClusterIP. Tuttavia, non puoi accedere a un servizio ClusterIP da Internet, ma puoi utilizzare il proxy Kubernetes. Per ulteriori informazioni sulle proxy, consulta la documentazione a monte.

Questa sezione espone echo1 e crea una comunicazione tra servizi all'interno del cluster utilizzando un pod Oracle Linux, dimostrando la comunicazione tra i componenti front-end e back-end dell'applicazione.

Recupera una lista di nodi.

kubectl get nodes

Output di esempio:

[oracle@ocne-node01 ~]$ kubectl get nodes
NAME          STATUS   ROLES    AGE     VERSION
ocne-node01   Ready    <none>   4h27m   v1.22.8+1.el8

I nodi sono sistemi fisici o Virtual Machine per la distribuzione di pod.

Eseguire una query sulla modalità kube-proxy.

L'esecuzione di kube-proxy in modalità iptables determina che i pacchetti inviati a un servizio ClusterIP non devono mai essere di origine NAT.
```
curl -w "\n" http://localhost:10249/proxyMode
```
- kube-proxy ascolta sulla porta 10249 sul nodo in cui è in esecuzione.

Creare il servizio ClusterIP.

kubectl expose deployment echo1 --name=clusterip-service --port=80 --target-port=8080

Recupera l'indirizzo IP assegnato al cluster.

kubectl get svc clusterip-service

Output di esempio:

[oracle@ocne-node01 ~]$ kubectl get svc clusterip-service
NAME                TYPE        CLUSTER-IP      EXTERNAL-IP   PORT(S)   AGE
clusterip-service   ClusterIP   10.108.107.54   <none>        80/TCP    13s

Prendere nota dell'indirizzo CLUSTER-IP nell'output.

Creare un pod nello stesso cluster per accedere al servizio ClusterIP.

kubectl run ol -it --image=oraclelinux:8 --restart=Never --rm

Questo comando creerà un pod che eseguirà un contenitore Oracle Linux 8 in modalità interattiva e mostrerà un prompt di comando.

Output di esempio:

[oracle@ocne-node01 ~]$ kubectl run ol -it --image=oraclelinux:8 --restart=Never --rm
If you don't see a command prompt, try pressing enter.
[root@ol /]#

Ottieni l'indirizzo IP del contenitore Oracle Linux.

ip -br a

Output di esempio:

[root@ol /]# ip -br a
lo               UNKNOWN        127.0.0.1/8 ::1/128 
eth0@if12        UP             10.244.0.9/24 fe80::146f:2cff:fe73:b528/64

Verificare il server Web nginx in echo1.

curl -w "\n" <CLUSTER-IP_ADDRESS>

Utilizzare l'indirizzo CLUSTER-IP dell'output precedente.

Output di esempio:

[root@ol /]# curl -w "\n" 10.108.107.54
CLIENT VALUES:
client_address=10.244.0.9
command=GET
real path=/
query=nil
request_version=1.1
request_uri=http://10.108.107.54:8080/

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

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

L'output mostra la richiesta di Oracle Linux e viene gestito dal servizio ClusterIP utilizzando la distribuzione echo1.

Uscire dal contenitore.

exit

Output di esempio:

[root@ol /]# exit
exit
pod "ol" deleted

Utilizza il servizio NodePort con un file YAML

In precedenza la distribuzione echo1 è stata esposta utilizzando il comando kubectl expose ed è stato eseguito l'accesso interno utilizzando ClusterIP. Ora verrà utilizzato un servizio NodePort, che rappresenta l'approccio di uno sviluppatore per avere l'accesso esterno di echo1 sulla rete.

Il servizio NodePort apre una porta specifica su tutti i nodi e inoltra qualsiasi traffico verso tale porta al servizio.

La procedura standard Nota non consiglia di utilizzare NodePort per i sistemi di produzione per diversi motivi, in particolare:

Ogni servizio distribuito richiede una porta diversa
I nodi devono essere disponibili pubblicamente, sicuramente non è consigliato.
Nessun bilanciamento del carico si verifica nei nodi (in un cluster Kubernetes a più nodi)

Definire un file di servizio.

cat << 'EOF' | tee myservice.yaml > /dev/null
apiVersion: v1
kind: Service
metadata:
  name: echo1-nodeport
  namespace: default
spec:
  ipFamilies:
  - IPv4
  ipFamilyPolicy: SingleStack
  ports:
  - nodePort: 32387
    port: 80
    protocol: TCP
    targetPort: 8080
  selector:
    app: echo1
  sessionAffinity: None
  type: NodePort
status:
  loadBalancer: {}
EOF

type: rende il servizio disponibile per le richieste di rete da client esterni. I valori validi sono nodePort, LooadBalancer.
nodePort: la porta esterna utilizzata per accedere al servizio.
porta: numero di porta esposto all'interno del cluster.
targetPort: la porta su cui è in ascolto il contenitore.

Creare il servizio.
```
kubectl apply -f myservice.yaml
```
Output di esempio:
```
[oracle@ocne-node01 ~]$ kubectl apply -f myservice.yaml 
service/echo1 created
```
Nota: è comune che le definizioni di distribuzione e servizio siano incluse nello stesso file YAML per semplificare la gestione di un'applicazione. L'utilizzo di file separati in questi passaggi è solo a scopo di formazione. Quando vengono combinati in un singolo file, utilizzare la sintassi YAML --- per separarli.

Visualizza in che modo Kubernetes memorizza il servizio appena creato.

kubectl get service echo1-nodeport -o yaml

Output di esempio:

[oracle@ocne-node01 ~]$ kubectl get service echo1-nodeport -o yaml
apiVersion: v1
kind: Service
metadata:
  annotations:
    kubectl.kubernetes.io/last-applied-configuration: |
      {"apiVersion":"v1","kind":"Service","metadata":{"annotations":{},"name":"echo1-nodeport","namespace":"default"},"spec":{"ipFamilies":["IPv4"],"ipFamilyPolicy":"SingleStack","ports":[{"nodePort":32387,"port":80,"protocol":"TCP","targetPort":8080}],"selector":{"app":"echo1"},"sessionAffinity":"None","type":"NodePort"},"status":{"loadBalancer":{}}}
  creationTimestamp: "2022-06-29T00:14:30Z"
  name: echo1-nodeport
  namespace: default
  resourceVersion: "6242"
  uid: 3171dda6-05b8-45b8-a0ba-457eab6e4f71
spec:
  clusterIP: 10.100.17.53
  clusterIPs:
  - 10.100.17.53
  externalTrafficPolicy: Cluster
  internalTrafficPolicy: Cluster
  ipFamilies:
  - IPv4
  ipFamilyPolicy: SingleStack
  ports:
  - nodePort: 32387
    port: 80
    protocol: TCP
    targetPort: 8080
  selector:
    app: echo1
  sessionAffinity: None
  type: NodePort
status:
  loadBalancer: {}

Descrivere il servizio Pods.

kubectl describe svc echo1-nodeport

Output di esempio:

[oracle@ocne-node01 ~]$ kubectl describe svc echo1-nodeport
Name:                     echo1-nodeport
Namespace:                default
Labels:                   <none>
Annotations:              <none>
Selector:                 app=echo1
Type:                     NodePort
IP Family Policy:         SingleStack
IP Families:              IPv4
IP:                       10.100.17.53
IPs:                      10.100.17.53
Port:                     <unset>  80/TCP
TargetPort:               8080/TCP
NodePort:                 <unset>  32387/TCP
Endpoints:                10.244.0.7:8080
Session Affinity:         None
External Traffic Policy:  Cluster
Events:                   <none>

Recupera gli endpoint dell'oggetto.

Gli endpoint tengono traccia degli indirizzi IP dei pod ai quali il servizio invia il traffico.

kubectl get endpoints echo1-nodeport

Output di esempio:

[oracle@ocne-node01 ~]$ kubectl get endpoints echo1-nodeport
NAME             ENDPOINTS         AGE
echo1-nodeport   10.244.0.7:8080   8m39s

Elencare i pod che eseguono l'applicazione.

kubectl get pods --output=wide

Output di esempio:

[oracle@ocne-node01 ~]$ kubectl get pods -o wide
NAME                     READY   STATUS    RESTARTS   AGE   IP           NODE          NOMINATED NODE   READINESS GATES
echo1-7cbf6dfb96-mlds4   1/1     Running   0          80m   10.244.0.7   ocne-node01   <none>           <none>
test-6c486b6d76-v4htj    1/1     Running   0          83m   10.244.0.6   ocne-node01   <none>           <none>

L'indirizzo IP in questa lista per echo1 deve corrispondere al valore visualizzato nel passo precedente per gli endpoint, che è l'indirizzo IP del pod in esecuzione sul nodo specificato.

Elencare i servizi.

kubectl get svc -o wide

Output di esempio:

[oracle@ocne-node01 ~]$ kubectl get svc -o wide
NAME                TYPE        CLUSTER-IP     EXTERNAL-IP   PORT(S)        AGE   SELECTOR
clusterip-service   ClusterIP   10.107.31.75   <none>        80/TCP         78m   app=echo1
echo1-nodeport      NodePort    10.100.17.53   <none>        80:32387/TCP   10m   app=echo1
kubernetes          ClusterIP   10.96.0.1      <none>        443/TCP        88m   <none>

Questo comando utilizzava l'opzione alternativa di -o wide anziché --output=wide.

Prendere nota di NodePort, impostato su 32387 per il servizio echo1-nodeport.

Recupera l'indirizzo IP del nodo.

L'ambiente di laboratorio gratuito viene eseguito su un singolo nodo ocne-node01.
```
ip -br a
```
Nell'ambiente di laboratorio gratuito, l'indirizzo IP deve restituire l'indirizzo IP privato dell'istanza 10.0.0.140 assegnato all'interfaccia ens3.

Utilizzare JSONPath per assegnare la variabile NodePort.

NODEPORT=$(kubectl get -o jsonpath="{.spec.ports[0].nodePort}" services echo1-nodeport)

Utilizzare JSONPath per assegnare l'IP del nodo a una variabile.

NODES=$(kubectl get nodes -o jsonpath='{ $.items[*].status.addresses[?(@.type=="InternalIP")].address }')

Creare una regola firewall.

Questa regola consente il traffico su node:nodeport, dove node è l'indirizzo IP host del sistema o della virtual machine su cui è in esecuzione il pod.
```
sudo firewall-cmd --permanent --add-port=$NODEPORT/tcp
sudo firewall-cmd --reload
```
Dopo --reload, il daemon firewall ricarica la configurazione, che include iptables. Poiché kube-proxy dipende da iptables, ci sarà un ritardo nella risposta da Servizi.
Utilizzare l'indirizzo del nodo e la porta del nodo per verificare l'applicazione.
```
curl -s $NODES:$NODEPORT
```
Output di esempio:
```
[oracle@ocne-node01 ~]$ curl -s $NODES:NODEPORT
CLIENT VALUES:
client_address=10.244.0.1
command=GET
real path=/
query=nil
request_version=1.1
request_uri=http://10.0.0.140:8080/

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

HEADERS RECEIVED:
accept=*/*
host=10.0.0.140:32387
user-agent=curl/7.61.1
BODY:
```
L'output mostra la richiesta dall'instradamento del nodo locale tramite il servizio NodePort, tramite kube-proxy e il pod che esegue la distribuzione echo1.

Nota: se l'output sembra rimanere in sospeso, ciò è dovuto alla ricarica precedente del firewall. Digitare Ctrl-C e riprovare.

Rimuovi distribuzioni e servizi

Una volta eseguiti i servizi o la distribuzione, rimuoverli da Kubernetes.

Rimuovi servizi.

kubectl delete svc clusterip-service echo1-nodeport

Rimuovi distribuzioni.

kubectl delete deployments echo1
kubectl delete deploy test

La rimozione degli oggetti può essere eseguita singolarmente o in gruppi. Per ulteriori informazioni, consultare il manuale di riferimento di Kubernetes.

Riepilogo

Questo laboratorio offre solo la sintesi più breve delle presentazioni alla funzionalità che l'utilizzo di un servizio di orchestrazione cloud nativo come Kubernetes garantisce a qualsiasi organizzazione che utilizzi Kubernetes per gestire le distribuzioni dei container. Questi esercizi forniscono il primo passo su quello che sarà probabilmente un lungo viaggio nella flessibilità che l'uso di Kubernetes può offrire.

Per ulteriori informazioni

Altre risorse di apprendimento

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

Per la documentazione sul prodotto, visitare Oracle Help Center.

Titolo e informazioni sul copyright

Run Kubernetes on Oracle Linux

F59593-01

June 2022