Remarque :

Ce tutoriel est disponible dans un environnement d'atelier gratuit fourni par Oracle.
Il utilise des exemples de valeur pour les informations d'identification Oracle Cloud Infrastructure, la location et les compartiments. A la fin de votre atelier, remplacez ces valeurs par celles propres à votre environnement cloud.

Exécuter Kubernetes sur Oracle Linux

Introduction

Kubernetes est grec pour pilote ou helmsman - en d'autres termes, la personne qui suit les commandes et dirige un navire vers son objectif ultime (plutôt que d'être le capitaine qui donne les ordres). Pour ce faire, Kubernetes est une plate-forme open source et extensible destinée au déploiement, à la gestion et à la mise à l'échelle d'applications en conteneur. Pour ce faire, il utilise plusieurs outils de ligne de commande. Cet exercice utilise l'un des fichiers kubectl et YAML pour définir les attributs requis pour l'organisation déployant l'application et comprendre comment configurer et gérer l'application une fois le déploiement terminé.

Tous les déploiements sur un cluster Kubernetes sont représentés sous forme d'objets. Ces objets déployés utilisent des fichiers YAML textuels pour fournir des détails sur l'état requis de toute application déployée sur le cluster. Ces fichiers YAML peuvent décrire les éléments suivants :

Applications en conteneur sur lesquelles exécuter les noeuds
Détails des ressources requises par l'application
Toutes les stratégies expliquant comment ces applications conservent leur état, telles que les stratégies de redémarrage, de mise à niveau, etc.

Ce troisième point, bien que important, est compliqué sans comprendre les bases. Par conséquent, nous allons arrêter pour le moment et traiter ce sujet dans les prochains tutoriels.

Ce tutoriel fonctionne avec Kubernetes exécuté dans un environnement Oracle Cloud Native Environment compact sur Oracle Linux. L'objectif n'est pas d'être un "guichet unique" pour tout ce qui est nécessaire pour administrer un déploiement de production. Elle introduit plutôt les compétences requises pour déployer une application échantillon fonctionnelle.

Objectifs

Examiner les différents composants de Kubernetes tels qu'un pod, un déploiement et un service
Examiner les différents objets Kubernetes
Déployer et tester un exemple de projet

Prérequis

Un système Oracle Linux 8 ou version ultérieure avec la configuration suivante :

un utilisateur non root disposant de privilèges sudo
Oracle Cloud Native Environment installé et configuré

Configurer l'environnement des exercices

Remarque : lorsque vous utilisez l'environnement d'atelier gratuit, reportez-vous à Oracle Linux Lab Basics pour obtenir des instructions de connexion et d'utilisation.

Informations : l'environnement d'atelier gratuit déploie Oracle Cloud Native Environment sur le noeud fourni, prêt à la création d'environnements. Ce déploiement prend environ 8 à 10 minutes après son lancement. Par conséquent, vous souhaiterez peut-être quitter l'application pendant son exécution, puis revenir à la fin de l'exercice.

S'il n'est pas déjà connecté, ouvrez un terminal et connectez-vous via SSH au système ocne-node01.
```
ssh oracle@<ip_address_of_ol_node>
```

Vérifiez que l'environnement est prêt.

kubectl get pods -A

Exemple de sortie :

[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

Création d'un déploiement sur un pod et détails de la demande

Dans Kubernetes, le déploiement est un terme technique faisant référence à un fichier qui régit le comportement et les caractéristiques d'un pod. Les administrateurs utilisent les déploiements pour indiquer à l'application ce qu'il faut faire et Kubernetes effectue la tâche pour atteindre cet état.

Les exemples utilisent une image qui contient un petit serveur Web nginx qui renvoie l'adresse IP source des demandes qu'il reçoit via un en-tête HTTP.

Créez un déploiement de echoserver.

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

Répertoriez tous les pods du cluster.

kubectl get pods

Exemple de sortie :

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

Remarque : le nom de pod contient une valeur de suffixe qui varie chaque fois que vous déployez le pod.

Utilisez JSONPath pour affecter le nom de pod à une variable.

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

Testez l'affectation de variable.

La commande kubectl get pods permet également de transmettre un nom de pod en tant que paramètre pour afficher uniquement les informations relatives à ce pod.
```
kubectl get pods $TESTPOD
```

Demander les informations sélectionnées sur le pod.

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

Exemple de sortie :

[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

Obtenez les détails du pod.

kubectl describe pod $TESTPOD

Exemple de sortie :

[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

Créer un déploiement avec un fichier YAML

L'utilisation des manifestes de déploiement Kubernetes définit la façon de déployer une application vers le cluster Kubernetes et de fournir l'accès à d'autres fonctionnalités Kubernetes telles que l'autorétablissement, l'évolutivité, la gestion des versions et les mises à jour non simultanées. Cet atelier ne traite pas des fonctionnalités plus complexes fournies dans Kubernetes. Elle illustre plutôt l'utilisation d'un fichier manifeste de base pour déployer une application.

Un fichier manifeste de déploiement est écrit au format JSON ou YAML. Bien que possible pour utiliser JSON, YAML est beaucoup plus populaire en raison de sa flexibilité, de sa lisibilité et de sa capacité à inclure des commentaires descriptifs pour clarifier les aspects du déploiement final.

Lors de l'exécution d'un déploiement, un pod est mis à jour via une série de mises à jour déclaratives pour atteindre l'état souhaité pour l'application en cours d'exécution.

Bien que tous les détails de deployment.yaml soient essentiels pour que Kubernetes puisse émettre la demande de déploiement, les éléments suivants mettent en évidence certaines des parties les plus vitales :

Le champ apiVersion indique la version d'API Kubernetes à utiliser. Définissez cette option sur apps/v1 si vous utilisez une version à jour de Kubernetes.
Dans ce cas, le champ kind informe Kubernetes de faire référence à un type d'objet appelé Deployment.
La section métadonnées permet de définir les détails du nom du déploiement et des libellés associés.
La section .spec est probablement la section la plus critique de tout fichier manifeste de déploiement. Tous les éléments d'ici vers le bas concernent le déploiement du pod. Tout élément figurant sous la section .spec.template décrit le modèle de pod utilisé par Kubernetes pour gérer le déploiement (dans cet exemple, il s'agit d'un conteneur unique).
Les autres champs non utilisés dans cet exemple sont le champ .spec.replicas (qui indique à Kubernetes le nombre de répliques de pod à déployer) et le champ .spec.strategy (qui indique à Kubernetes comment effectuer les mises à jour du déploiement).

Pour plus d'informations sur ces autres champs, reportez-vous à la documentation relative aux déploiements en amont.

Créez le fichier de déploiement.

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

Déployez l'application sur un pod à l'aide du fichier manifeste de déploiement.

kubectl apply -f mydeployment.yaml

Exemple de sortie :

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

Répertoriez le pod géré par le déploiement.
```
kubectl get pods -l app=echo1
```
Exemple de sortie :
```
[oracle@ocne-node01 ~]$ kubectl get pods -l app=echo1
NAME                     READY   STATUS    RESTARTS   AGE
echo1-7cbf6dfb96-4cgq7   1/1     Running   0          24s
```
- L'option -l ou --selector= fournit un sélecteur (requête de libellé) sur lequel filtrer. Cette option prend en charge les caractères '=', '==' et ' !='.(par exemple, -l key1=value1,key2=value2)
Remarque : rappelons que le nom de pod contient une valeur de suffixe qui varie chaque fois que vous déployez le pod.
Vérifiez que le déploiement a réussi.
```
kubectl get deploy echo1
```
Exemple de sortie :
```
[oracle@ocne-node01 ~]$ kubectl get deploy echo1
NAME    READY   UP-TO-DATE   AVAILABLE   AGE
echo1   1/1     1            1           16m
```
- L'option deploy est à court terme pour deployments. La commande kubectl permet d'utiliser une syntaxe abrégée pour de nombreuses options. Pour plus de détails, exécutez kubectl --help.

Renvoyer des informations plus détaillées pour un déploiement.

kubectl describe deploy echo1

Exemple de sortie :

[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

Utiliser le service ClusterIP

Malgré le déploiement réussi du déploiement echo1 vers un pod, il est peu utile que les utilisateurs finals ne puissent pas y accéder en interne ou sur le réseau. Cet accès est utile lorsqu'un service expose un déploiement au réseau.

Le type de service Kubernetes par défaut est ClusterIP. Cependant, vous ne pouvez pas accéder à un service ClusterIP à partir d'Internet, mais vous pouvez utiliser le proxy Kubernetes. Pour plus d'informations sur les proxies, reportez-vous à la documentation en amont.

Cette section présente echo1 et crée une communication inter-service dans le cluster à l'aide d'un pod Oracle Linux, illustrant la communication entre les composants frontaux et back-end de votre application.

Obtenir la liste des noeuds.

kubectl get nodes

Exemple de sortie :

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

Les noeuds sont les systèmes physiques ou les machines virtuelles permettant de déployer des pods.

Interrogez le mode kube-proxy.

L'exécution de kube-proxy en mode iptables entraîne l'absence de NAT source pour les paquets envoyés à un service ClusterIP.
```
curl -w "\n" http://localhost:10249/proxyMode
```
- kube-proxy écoute le port 10249 sur le noeud sur lequel il s'exécute.

Créez le service ClusterIP.

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

Obtenir l'adresse IP affectée au cluster.

kubectl get svc clusterip-service

Exemple de sortie :

[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

Notez l'adresse CLUSTER-IP dans la sortie.

Créez un pod dans le même cluster pour accéder au service ClusterIP.

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

Cette commande crée un pod exécutant un conteneur Oracle Linux 8 en mode interactif et présente une invite de commande.

Exemple de sortie :

[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 /]#

Obtenez l'adresse IP du conteneur Oracle Linux.

ip -br a

Exemple de sortie :

[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

Testez le serveur Web nginx dans echo1.

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

Utilisez l'adresse CLUSTER-IP de la sortie précédente.

Exemple de sortie :

[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-

La sortie présente la demande d'Oracle Linux et est gérée par le service ClusterIP à l'aide du déploiement echo1.

Quittez le conteneur.

exit

Exemple de sortie :
[root@ol /]# exit
exit
pod "ol" deleted

Utiliser le service NodePort avec un fichier YAML

Auparavant, le déploiement echo1 était exposé à l'aide de la commande kubectl expose et était accessible en interne à l'aide de ClusterIP. Nous allons maintenant utiliser un service NodePort qui est une approche du développeur pour que echo1 soit accessible en externe sur le réseau.

Le service NodePort ouvre un port spécifique sur tous les noeuds et transfère tout trafic vers ce port au service.

Remarque Les pratiques standard ne recommandent pas d'utiliser NodePort pour les systèmes de production pour plusieurs raisons, notamment :

Chaque service déployé nécessite un port différent
Les noeuds doivent être disponibles publiquement, ce qui n'est pas recommandé.
Aucun équilibrage de charge n'est effectué sur les noeuds (dans un cluster Kubernetes multinoeud)

Définissez un fichier de service.

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 : met le service à la disposition des demandes réseau des clients externes. Valeurs valides : nodePort, LooadBalancer.
nodePort : port externe utilisé pour accéder au service.
port : numéro de port affiché dans le cluster.
targetPort : port sur lequel le conteneur écoute.

Créez le service.
```
kubectl apply -f myservice.yaml
```
Exemple de sortie :
```
[oracle@ocne-node01 ~]$ kubectl apply -f myservice.yaml 
service/echo1 created
```
Remarque : il est courant que les définitions de déploiement et de service se trouvent dans le même fichier YAML pour simplifier la gestion d'une application. L'utilisation de fichiers distincts dans ces étapes est réservée à la formation. Lorsque vous les combinez en un seul fichier, utilisez la syntaxe YAML --- pour les séparer.

Affichez la façon dont Kubernetes stocke le service nouvellement créé.

kubectl get service echo1-nodeport -o yaml

Exemple de sortie :

[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: {}

Décrivez le service Pods.

kubectl describe svc echo1-nodeport

Exemple de sortie :

[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>

Obtenez les adresses d'objet.

Les adresses suivent les adresses IP des pods vers lesquels le service envoie le trafic.

kubectl get endpoints echo1-nodeport

Exemple de sortie :

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

Répertoriez les pods qui exécutent l'application.

kubectl get pods --output=wide

Exemple de sortie :

[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'adresse IP de cette liste pour echo1 doit correspondre à la valeur indiquée à l'étape précédente pour les adresses, à savoir l'adresse IP du pod en cours d'exécution sur le noeud spécifié.

Répertoriez les services.

kubectl get svc -o wide

Exemple de sortie :

[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>

Cette commande utilisait l'option alternative de -o wide, plutôt que --output=wide.

Notez le fichier NodePort, qui est défini sur 32387 pour le service echo1-nodeport.

Obtenez l'adresse IP du noeud.

L'environnement d'atelier gratuit s'exécute sur un seul noeud ocne-node01.
```
ip -br a
```
Dans l'environnement d'exercice gratuit, l'adresse IP doit renvoyer l'adresse IP privée de l'instance 10.0.0.140 affectée à l'interface ens3.

Utilisez JSONPath pour affecter une variable NodePort.

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

Utilisez JSONPath pour affecter l'adresse IP de noeud à une variable.

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

Créez une règle de pare-feu.

Cette règle autorise le trafic sur node:nodeport, où node est l'adresse IP de l'hôte du système ou de la machine virtuelle sur lequel le pod est exécuté.
```
sudo firewall-cmd --permanent --add-port=$NODEPORT/tcp
sudo firewall-cmd --reload
```
Après --reload, le démon firewalld recharge sa configuration, qui inclut iptables. Comme kube-proxy dépend de iptables, la réponse des services sera retardée.
Utilisez l'adresse et le port du noeud pour vérifier l'application.
```
curl -s $NODES:$NODEPORT
```
Exemple de sortie :
```
[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:
```
La sortie affiche la demande du routage de noeud local via le service NodePort, via kube-proxy et vers le pod exécutant le déploiement echo1.

Remarque : si la sortie semble bloquée, cela est dû au rechargement précédent du pare-feu. Saisissez Ctrl-C et réessayez.

Enlever les déploiements et les services

Une fois le service ou le déploiement terminé, enlevez-les de Kubernetes.

Enlevez des services.

kubectl delete svc clusterip-service echo1-nodeport

Enlevez les déploiements.

kubectl delete deployments echo1
kubectl delete deploy test

La suppression d'objets peut être effectuée individuellement ou par groupes. Pour plus d'informations, reportez-vous au manuel de référence Kubernetes.

Synthèse

Ce laboratoire n'offre que la version la plus courte des introductions disponibles avec un orchestrateur cloud natif tel que Kubernetes pour gérer ses déploiements de conteneur à l'aide de Kubernetes. Ces exercices constituent la première étape sur ce qu'est probablement un long parcours vers la flexibilité offerte par Kubernetes.

Pour plus d'informations

Ressources de formation supplémentaires

Explorez d'autres ateliers sur docs.oracle.com/learn ou accédez à davantage de contenu de formation gratuit sur le canal Oracle Learning YouTube. En outre, accédez à education.oracle.com/learning-explorer pour devenir explorateur Oracle Learning.

Pour consulter la documentation du produit, consultez Oracle Help Center.

Informations relatives au titre et au copyright

Run Kubernetes on Oracle Linux

F59596-01

June 2022