Nota:

Este tutorial está disponible en un entorno de laboratorio gratuito proporcionado por Oracle.
Utiliza valores de ejemplo para las credenciales, el arrendamiento y los compartimentos de Oracle Cloud Infrastructure. Al finalizar la práctica, sustituya estos valores por valores específicos de su entorno en la nube.

Ejecute Kubernetes en Oracle Linux

Introducción

Kubernetes es griego para piloto o helmsman, es decir, la persona que sigue órdenes y dirige un barco hacia su objetivo final (en lugar de ser el Capitán que da órdenes). Para ello, Kubernetes es una plataforma de código abierto y ampliable para desplegar, gestionar y ampliar aplicaciones en contenedores. Para ello, utiliza varias herramientas de línea de comandos. En este laboratorio se utiliza uno de los denominados kubectl junto con los archivos YAML para definir los atributos necesarios para la organización que despliega la aplicación y comprender cómo configurar y mantener la aplicación una vez que haya terminado de desplegarla.

Todos los despliegues en un cluster de Kubernetes se representan como objetos. Estos objetos desplegados utilizan archivos YAML basados en texto para proporcionar detalles del estado necesario de cualquier aplicación desplegada en el cluster. Estos archivos YAML pueden describir lo siguiente:

Qué aplicaciones en contenedores ejecutar en qué nodos
Detalles de los recursos necesarios para la aplicación
Cualquier política que detalle cómo estas aplicaciones mantienen su estado, como políticas de reinicio, políticas de actualización, etc.

Este tercer punto, aunque importante, es complicado sin entender los conceptos básicos. Por lo tanto, nos mantendremos al tanto de ahora y trataremos ese tema en futuros tutoriales.

Este tutorial funciona con Kubernetes que se ejecuta en un entorno compacto de Oracle Cloud Native Environment en Oracle Linux. La intención no es ser una "tienda única" para todo lo necesario para administrar un despliegue de producción. En su lugar, presenta las habilidades necesarias para desplegar una aplicación de ejemplo de trabajo.

Objetivos

Examinar los diferentes componentes de Kubernetes como un pod, despliegue y servicio
Examinar los distintos objetos de Kubernetes
Desplegar y probar un proyecto de ejemplo

Requisitos

Un sistema Oracle Linux 8 o posterior con la siguiente configuración:

un usuario no raíz con privilegios sudo
Oracle Cloud Native Environment instalada y configurada

Configuración del entorno de prácticas

Nota: Al utilizar el entorno de prácticas gratuitas, consulte Aspectos básicos de las prácticas de Oracle Linux para obtener información sobre la conexión y otras instrucciones de uso.

Información: el entorno de laboratorio gratuito despliega Oracle Cloud Native Environment en el nodo proporcionado, listo para crear entornos. Este despliegue tarda aproximadamente entre 8 y 10 minutos en completarse después del inicio. Por lo tanto, es posible que desee alejarse mientras se ejecuta y, a continuación, volver a completar el laboratorio.

Si aún no está conectado, abra un terminal y conéctese mediante ssh al sistema ocne-node01.
```
ssh oracle@<ip_address_of_ol_node>
```

Confirme que el entorno está listo.

kubectl get pods -A

Resultado de ejemplo:

[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

Creación de un Despliegue en un Pod y Detalles de Solicitud

En Kubernetes, el despliegue es un término técnico que hace referencia a un archivo que controla el comportamiento y las características de un pod. Los administradores utilizan los despliegues para indicar a la aplicación qué hacer, y Kubernetes realiza la tarea para alcanzar ese estado.

Los ejemplos utilizan una imagen que contiene un pequeño servidor web de nginx que hace un eco de la IP de origen de las solicitudes que recibe a través de una cabecera HTTP.

Cree un despliegue de echoserver.

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

Mostrar todos los pods del cluster.

kubectl get pods

Resultado de ejemplo:

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

Nota: El nombre de pod contiene un valor de sufijo que varía cada vez que se despliega el pod.

Utilice JSONPath para asignar el nombre de pod a una variable.

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

Pruebe la asignación de la variable.

El comando kubectl get pods también permite transferir un nombre de pod como parámetro para mostrar solo la información de ese pod.
```
kubectl get pods $TESTPOD
```

Solicite información seleccionada sobre el Pod.

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

Resultado de ejemplo:

[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

Obtenga los detalles del pod.

kubectl describe pod $TESTPOD

Resultado de ejemplo:

[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

Creación de un despliegue con un archivo YAML

Los manifiestos de despliegue de Kubernetes definen cómo desplegar una aplicación en el cluster de Kubernetes y proporcionan acceso a otras funcionalidades de Kubernetes como la reparación automática, la escalabilidad, el control de versiones y las actualizaciones sucesivas. En este laboratorio no se abordará esta funcionalidad más compleja proporcionada en Kubernetes. En su lugar, ilustra cómo utilizar un archivo de manifiesto muy básico para desplegar una aplicación.

Un archivo de manifiesto de despliegue se escribe en JSON o en YAML. Aunque es posible utilizar JSON, YAML es mucho más popular debido a su flexibilidad, legibilidad y capacidad para incluir comentarios descriptivos para aclarar aspectos del despliegue final.

Al ejecutar un despliegue, se actualiza un pod mediante una serie de actualizaciones declarativas para alcanzar el estado deseado de la aplicación en ejecución.

Si bien todos los detalles de deployment.yaml son esenciales para que Kubernetes pueda promulgar la solicitud de despliegue, lo siguiente resalta algunas de las partes más importantes:

El campo apiVersion especifica la versión de API de Kubernetes que se va a utilizar. Defina esta opción en apps/v1 si utiliza una versión actualizada de Kubernetes.
En este caso, el campo kind informa a Kubernetes que hace referencia a un tipo de objeto denominado Deployment.
La sección metadatos se utiliza para describir los detalles del nombre de despliegue y las etiquetas asociadas
La sección .spec es probablemente la sección más crítica de cualquier archivo de manifiesto de despliegue. Cualquier cosa desde aquí hacia abajo está relacionada con el despliegue del Pod. Todo lo que esté debajo de la sección .spec.template describe la plantilla de pod que Kubernetes utiliza para gestionar el despliegue (en este ejemplo, es un único contenedor).
Otros campos que no se utilizan en este ejemplo son el campo .spec.replicas (que indica a Kubernetes cuántas réplicas de pod desplegar) y el campo .spec.strategy (que indica a Kubernetes cómo realizar actualizaciones en el despliegue).

Consulte la documentación ascendente de Despliegues para obtener más información sobre estos otros campos.

Cree el archivo de despliegue.

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

Despliegue la aplicación en un Pod mediante el archivo de manifiesto Deployment.

kubectl apply -f mydeployment.yaml

Resultado de ejemplo:

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

Mostrar el pod gestionado por el despliegue.
```
kubectl get pods -l app=echo1
```
Resultado de ejemplo:
```
[oracle@ocne-node01 ~]$ kubectl get pods -l app=echo1
NAME                     READY   STATUS    RESTARTS   AGE
echo1-7cbf6dfb96-4cgq7   1/1     Running   0          24s
```
- La opción -l o --selector= proporciona un selector (consulta de etiqueta) para filtrar. Esta opción admite '=', '==' y '!='.(por ejemplo, -l key1=value1,key2=value2)
Nota: Recuerde que el nombre de pod contiene un valor de sufijo que varía cada vez que se despliega el pod.
Verifique que el despliegue se haya realizado correctamente.
```
kubectl get deploy echo1
```
Resultado de ejemplo:
```
[oracle@ocne-node01 ~]$ kubectl get deploy echo1
NAME    READY   UP-TO-DATE   AVAILABLE   AGE
echo1   1/1     1            1           16m
```
- La opción deploy es de mano corta para deployments. El comando kubectl permite utilizar una sintaxis abreviada para muchas de sus opciones. Para obtener más información, ejecute kubectl --help.

Devolver información más detallada para un despliegue.

kubectl describe deploy echo1

Resultado de ejemplo:

[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

Utilizar el servicio ClusterIP

A pesar de desplegar correctamente el echo1 despliegue en un pod, no se utiliza mucho si los usuarios finales no pueden acceder a él internamente o en la red. Este acceso es donde un servicio resulta útil cuando expone un despliegue a la red.

El tipo de servicio de Kubernetes por defecto es ClusterIP. Sin embargo, no puede acceder a un servicio ClusterIP desde Internet, pero puede utilizar el proxy de Kubernetes. Consulte la documentación ascendente para obtener más información sobre los proxies.

En esta sección, se muestra echo1 y se crea comunicación entre servicios en el cluster mediante un pod de Oracle Linux que demuestra la comunicación entre los componentes front-end y backend de la aplicación.

Obtenga una lista de nodos.

kubectl get nodes

Resultado de ejemplo:

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

Los nodos son los sistemas físicos o las máquinas virtuales para desplegar pods.

Consulte el modo kube-proxy.

La ejecución de kube-proxy en el modo iptables hace que los paquetes enviados a un servicio ClusterIP nunca sean NAT'd de origen.
```
curl -w "\n" http://localhost:10249/proxyMode
```
- kube-proxy recibe en el puerto 10249 en el nodo donde se ejecuta.

Cree el servicio ClusterIP.

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

Obtener la dirección IP asignada al cluster.

kubectl get svc clusterip-service

Resultado de ejemplo:

[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

Tome nota de la dirección CLUSTER-IP en la salida.

Cree un pod en el mismo cluster para acceder al servicio ClusterIP.

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

Este comando creará un pod que ejecute un contenedor de Oracle Linux 8 en modo interactivo y presentará un símbolo del sistema.

Resultado de ejemplo:

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

Obtenga la dirección IP del contenedor de Oracle Linux.

ip -br a

Resultado de ejemplo:

[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

Pruebe el servidor web nginx en echo1.

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

Utilice la dirección CLUSTER-IP de la salida anterior.

Resultado de ejemplo:

[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 salida muestra la solicitud de Oracle Linux y la gestiona el servicio ClusterIP mediante el despliegue echo1.

Salga del contenedor.

exit

Resultado de ejemplo:
[root@ol /]# exit
exit
pod "ol" deleted

Uso del servicio NodePort con un archivo YAML

Anteriormente, el despliegue echo1 se expuso mediante el comando kubectl expose y se accedió internamente mediante ClusterIP. Ahora, usaremos un servicio NodePort, que es un enfoque del desarrollador para que echo1 sea accesible externamente a través de la red.

El servicio NodePort abre un puerto específico en todos los nodos y reenvía cualquier tráfico a ese puerto al servicio.

Nota La práctica estándar no recomienda utilizar NodePort para sistemas de producción por varios motivos, principalmente los siguientes:

Cada servicio desplegado requiere un puerto diferente
Los nodos deben estar disponibles públicamente, lo que definitivamente no se recomienda.
No se produce equilibrio de carga en los nodos (en un cluster de Kubernetes de varios nodos)

Defina un archivo de servicio.

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: hace que el servicio esté disponible para las solicitudes de red de clientes externos. Los valores válidos son: nodePort, LooadBalancer.
nodePort: puerto externo utilizado para acceder al servicio.
puerto: número de puerto expuesto en el cluster.
targetPort: puerto en el que recibe el contenedor.

Cree el servicio.
```
kubectl apply -f myservice.yaml
```
Resultado de ejemplo:
```
[oracle@ocne-node01 ~]$ kubectl apply -f myservice.yaml 
service/echo1 created
```
Nota: Es común tener las definiciones de despliegue y servicio en el mismo archivo YAML para simplificar la gestión de una aplicación. El uso de archivos independientes en estos pasos es solo para fines de formación. Al combinarlos en un único archivo, utilice la sintaxis --- YAML para separarlos.

Muestre cómo Kubernetes almacena el servicio recién creado.

kubectl get service echo1-nodeport -o yaml

Resultado de ejemplo:

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

Describir el servicio Pods.

kubectl describe svc echo1-nodeport

Resultado de ejemplo:

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

Obtenga los puntos finales del objeto.

Los puntos finales realizan un seguimiento de las direcciones IP de los pods a los que el servicio envía tráfico.

kubectl get endpoints echo1-nodeport

Resultado de ejemplo:

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

Muestre los pods que ejecutan la aplicación.

kubectl get pods --output=wide

Resultado de ejemplo:

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

La dirección IP de esta lista para echo1 debe coincidir con el valor mostrado en el paso anterior para los puntos finales, que es la dirección IP del pod que se ejecuta en el nodo especificado.

Muestre los servicios.

kubectl get svc -o wide

Resultado de ejemplo:

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

Este comando utilizó la opción alternativa de -o wide, en lugar de --output=wide.

Tome nota de NodePort, que se establece en 32387 para el servicio echo1-nodeport.

Obtenga la dirección IP del nodo.

El entorno de prácticas gratuitas se ejecuta en un único nodo ocne-node01.
```
ip -br a
```
En el entorno de prácticas libres, la dirección IP debe devolver la dirección IP privada de la instancia de 10.0.0.140 asignada a la interfaz ens3.

Utilice JSONPath para asignar la variable NodePort.

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

Utilice JSONPath para asignar la IP de nodo a una variable.

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

Cree una regla de firewall.

Esta regla permite el tráfico en node:nodeport, donde node es la dirección IP del host del sistema o la máquina virtual en la que se ejecuta el pod.
```
sudo firewall-cmd --permanent --add-port=$NODEPORT/tcp
sudo firewall-cmd --reload
```
Después de --reload, el daemon firewalld vuelve a cargar su configuración, que incluye iptables. Dado que kube-proxy depende de iptables, habrá un retraso en la respuesta de los servicios.
Utilice la dirección del nodo y el puerto del nodo para verificar la aplicación.
```
curl -s $NODES:$NODEPORT
```
Resultado de ejemplo:
```
[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 salida muestra la solicitud del enrutamiento del nodo local a través del servicio NodePort, a través de kube-proxy, y al Pod que ejecuta el despliegue echo1.

Nota: Si la salida parece bloquearse, se debe a la recarga anterior del firewall. Escriba Ctrl-C y vuelva a intentarlo.

Eliminar despliegues y servicios

Una vez realizado un servicio o despliegue, elimínelos de Kubernetes.

Eliminar servicios.

kubectl delete svc clusterip-service echo1-nodeport

Eliminar despliegues.

kubectl delete deployments echo1
kubectl delete deploy test

La eliminación de objetos se puede realizar de forma individual o en grupos. Consulte el Manual de referencia de Kubernetes para obtener más información.

Resumen

En este laboratorio se ofrece solo la más breve introducción a la funcionalidad que utiliza una organización en la nube como Kubernetes proporciona a cualquier organización que utiliza Kubernetes para gestionar sus despliegues de contenedor. Estos ejercicios proporcionan el primer paso sobre lo que probablemente será un largo recorrido hacia la flexibilidad que puede ofrecer Kubernetes.

Para obtener más información

Más recursos de aprendizaje

Explore otros laboratorios en docs.oracle.com/learn o acceda a más contenido de aprendizaje gratuito en el canal YouTube de Oracle Learning. Además, visite education.oracle.com/learning-explorer y conviértase en Oracle Learning Explorer.

Para obtener documentación sobre el producto, visite Oracle Help Center.

Título e Información de Copyright

Run Kubernetes on Oracle Linux

F59592-01

June 2022