Note:

Este tutorial requiere acceso a Oracle Cloud. Para registrarse para obtener una cuenta gratuita, consulte Introducción a la cuenta gratuita de Oracle Cloud Infrastructure.
Utiliza valores de ejemplo para credenciales, arrendamiento y compartimentos de Oracle Cloud Infrastructure. Al finalizar la práctica, sustituya estos valores por otros específicos de su entorno en la nube.

Aprovechar el túnel SSH con Oracle Cloud Infrastructure Kubernetes Engine para desarrollar aplicaciones seguras

Introducción

Cuando conseguí un túnel SSH con OKE trabajando con la ayuda de Ali Mukadam, lo llamé "magia".

Él me respondió con el siguiente mensaje:

"Lo llamaste magia, otros lo llaman ciencia. Donde yo estoy son uno y lo mismo".

La cita original es de una película de Thor:

"Sus antepasados lo llamaron magia, pero lo llaman ciencia. Vengo de una tierra donde son uno y lo mismo".

¿Qué es esta magia?

En el desarrollo moderno de aplicaciones, es esencial proteger las conexiones entre los recursos locales y basados en la nube, especialmente cuando se trabaja con Oracle Cloud Infrastructure Kubernetes Engine (OCI Kubernetes Engine u OKE). El túnel SSH ofrece una forma sencilla pero potente de conectarse de forma segura a clusters de OKE, lo que permite a los desarrolladores gestionar e interactuar con recursos sin exponerlos a la red pública de Internet. Este tutorial explora cómo configurar el túnel SSH con OKE y cómo los desarrolladores pueden integrar este enfoque en su flujo de trabajo para mejorar la seguridad y la eficiencia. Desde la configuración inicial hasta las mejores prácticas, cubriremos todo lo que necesita para aprovechar el túnel SSH de manera efectiva en sus aplicaciones basadas en OKE.

En la siguiente imagen, se muestran los flujos de tráfico completos de la creación de túneles SSH para dos aplicaciones diferentes.

Objetivos

Aproveche el túnel SSH con OKE para el desarrollo seguro de aplicaciones.

Tarea 1: Despliegue del cluster de Kubernetes en OKE (con una instancia de bastión y operador)

Asegúrese de tener un cluster de Kubernetes desplegado en OKE.

Para desplegar un cluster de Kubernetes en OKE, utilice uno de los siguientes métodos:
- Despliegue de un cluster de Kubernetes con Terraform mediante Oracle Cloud Infrastructure Kubernetes Engine: despliegue un único cluster de Kubernetes en OKE mediante Terraform.
- Uso de Terraform para desplegar varios clusters de Kubernetes en distintas regiones de OCI mediante OKE y creación de una red de malla completa mediante RPC: despliegue de varios clusters de Kubernetes en varias regiones de OKE mediante Terraform.
- Tarea 1: creación de un nuevo cluster de Kubernetes y verificación de los componentes: despliegue un cluster de Kubernetes en OKE mediante el modo de creación rápida.
- Tarea 1: desplegar un cluster de Kubernetes mediante OKE: desplegar un cluster de Kubernetes en OKE con el modo Creación personalizada.
En este tutorial, utilizaremos Desplegar un cluster de Kubernetes con Terraform mediante Oracle Cloud Infrastructure Kubernetes Engine como cluster de Kubernetes base en OKE para explicar cómo podemos utilizar un túnel SSH para acceder a una aplicación basada en contenedor desplegada en OKE con localhost.

Revisemos rápidamente el entorno de OCI OKE para preparar el escenario.
Red virtual en la nube (VCN)

Conéctese a la consola de OCI y vaya a Networking y Virtual Cloud Networks.
- Revise la VCN denominada oke.
- Haga clic en la VCN de oke.
Subredes

Vaya a la página de detalles de la VCN.
1. Haga clic en Subnets.
2. Revise las subredes desplegadas.
Gateways

Vaya a la página de detalles de la VCN.
1. Haga clic en Gateways de Internet.
2. Revise el gateway de Internet creado.
1. Haga clic en Gateways de NAT.
2. Revise el gateway de NAT creado.
1. Haga clic en Gateways de servicio.
2. Revise el gateway de servicio creado.
1. Haga clic en Listas de seguridad.
2. Revisión de las listas de seguridad creadas.
Pools de nodos

Vaya a Developer Services y Container & Artifacts.
1. Haga clic en Clusters de Kubernetes (OKE).
2. Haga clic en el cluster de oke.
1. Haga clic en Pools de nodos.
2. Revise los pools de nodos.
Instancias

Vaya a Compute e Instances.
1. Haga clic en Instancias.
2. Revise los despliegues de los nodos de trabajo de Kubernetes.
3. Revise el despliegue del host de bastión.
4. Revise el despliegue de Kubernetes Operator.
La siguiente imagen ilustra una visión general completa de cuál será nuestro punto de partida para el contenido restante de este tutorial.
La siguiente imagen ilustra una vista simplificada de la figura anterior. Usaremos esta figura en el resto de este tutorial.

Tarea 2: Despliegue de un servidor web NGINX en el cluster de Kubernetes

No se puede acceder directamente al operador desde Internet y tenemos que pasar por el host Bastion.

En este tutorial, estamos utilizando un script SSH proporcionado por Ali Mukadam para conectarse al operador utilizando un solo comando SSH. Esta secuencia de comandos y el método para conectarse se proporcionan aquí: Tarea 4: uso de bastión y operador para comprobar la conectividad. Necesitará este script más adelante en este tutorial, así que asegúrese de utilizarlo.
- Configure una sesión SSH para el operador de Kubernetes.
- Revise los nodos de trabajador activos con el comando kubectl get nodes.
- Revise todos los nodos de trabajador activos.

Para crear una aplicación NGINX de ejemplo que se esté ejecutando dentro de un contenedor, cree un archivo YAML denominado modified2_nginx_ext_lb.yaml con el siguiente código en el operador.

El archivo YAML contiene el código para crear la aplicación del servidor web NGINX con 3 réplicas, y también creará un servicio del tipo equilibrador de carga.

modified2_nginx_ext_lb.yaml:

apiVersion: apps/v1
kind: Deployment
metadata:
  name: my-nginx
  labels:
    app: nginx
spec:
  replicas: 3
  selector:
    matchLabels:
      app: nginx
  template:
    metadata:
      labels:
  app: nginx
    spec:
      containers:
      - name: nginx
        image: nginx:latest
        ports:
  - containerPort: 80
---
apiVersion: v1
kind: Service
metadata:
  name: my-nginx-svc
  labels:
    app: nginx
  annotations:
    oci.oraclecloud.com/load-balancer-type: "lb"
    service.beta.kubernetes.io/oci-load-balancer-internal: "true"
    service.beta.kubernetes.io/oci-load-balancer-subnet1: "ocid1.subnet.oc1.me-abudhabi-1.aaaaaaaaguwakvc6jxxxxxxxxxxxxxxxxxxxu7rixvdf5urvpxldhya"
    service.beta.kubernetes.io/oci-load-balancer-shape: "flexible"
    service.beta.kubernetes.io/oci-load-balancer-shape-flex-min: "50"
    service.beta.kubernetes.io/oci-load-balancer-shape-flex-max: "100"
spec:
  type: LoadBalancer
  ports:
  - port: 80
  selector:
    app: nginx

Queremos que esta aplicación sea accesible internamente y decidimos crear el servicio de tipo equilibrador de carga asociado a la subred privada del equilibrador de carga.

Para asignar el servicio de tipo equilibrador de carga a una subred privada del equilibrador de carga, necesita el OCID de subred de la subred privada del equilibrador de carga y debe agregar el siguiente código en la sección annotaciones.

annotations:
  oci.oraclecloud.com/load-balancer-type: "lb"
  service.beta.kubernetes.io/oci-load-balancer-internal: "true"
  service.beta.kubernetes.io/oci-load-balancer-subnet1: "ocid1.subnet.oc1.me-abudhabi-1.aaaaaaaaguwakvcxxxxxxxxxxxxxxxxxxxxxxxxxxxxixvdf5urvpxldhya"
  service.beta.kubernetes.io/oci-load-balancer-shape: "flexible"
  service.beta.kubernetes.io/oci-load-balancer-shape-flex-min: "50"
  service.beta.kubernetes.io/oci-load-balancer-shape-flex-max: "100"

Para obtener el OCID de subred de la subred privada del equilibrador de carga, haga clic en la subred interna del equilibrador de carga.

Haga clic en Mostrar y en Copiar para obtener el OCID de subred del equilibrador de carga privado completo. Utilice este OCID en la sección annotations.
Para desplegar la aplicación NGINX y el servicio de tipo equilibrador de carga, ejecute los siguientes comandos:
1. Para crear el archivo YAML en el operador.
```
nano modified2_nginx_ext_lb.yaml
```
2. Desplegar la aplicación NGINX con el servicio de tipo equilibrador de carga.
```
kubectl apply -f modified2_nginx_ext_lb.yaml
```
  Verificar si la aplicación NGINX se ha desplegado correctamente (no se muestra en la imagen).
```
kubectl get pods
```
3. Para verificar si el servicio del tipo equilibrador de carga se ha desplegado correctamente.
```
kubectl get svc
```
4. Observe que el servicio del tipo equilibrador de carga se ha desplegado correctamente.
Al consultar la subred del equilibrador de carga interno, podemos ver que el bloque CIDR de esta subred es 10.0.2.0/27. El nuevo servicio del equilibrador de carga tiene la dirección IP 10.0.2.3.
Para verificar el objeto del equilibrador de carga en la consola de OCI, vaya a Networking, Load Balancer y haga clic en Load Balancer.
La siguiente imagen ilustra el despliegue que hemos realizado hasta ahora. Observe que se agrega el equilibrador de carga.

Prueba del nuevo pod/aplicación

Enfoque 1: Desde un pod temporal

Para probar si la aplicación NGINX recién desplegada está trabajando con el servicio del tipo equilibrador de carga, podemos realizar una prueba de conectividad interna mediante un pod temporal.

Hay varias formas de probar la conectividad a la aplicación, una forma sería abrir un navegador y probar si puede acceder a la página web. Pero cuando no tenemos un navegador disponible podemos hacer otra prueba rápida mediante el despliegue de un pod temporal.

Para crear un pod temporal y utilizarlo para pruebas de conectividad, consulte Tarea 3: despliegue de una aplicación web y un servicio de ejemplo.
- Ejecute el siguiente comando:
  1. Obtener la dirección IP del servicio de equilibrador de carga interno.
    kubectl get svc
  2. Para desplegar un pod de ejemplo para probar la conectividad de la aplicación web.
    kubectl run --rm -i -t --image=alpine test-$RANDOM -- sh
  3. Para probar la conectividad con el servidor web mediante wget.
    wget -qO- http://<ip-of-internal-lb-service>
  4. Observe el código HTML que devuelve el servidor web, confirmando que el servidor web y la conectividad que utiliza el servicio de equilibrio de carga interno están funcionando.
- Ejecute el siguiente comando para salir del pod temporal.
```
exit
```
  Observe que el pod se suprime inmediatamente después de cerrar la interfaz de línea de comandos.
- La siguiente imagen ilustra el despliegue que hemos realizado hasta ahora. Tenga en cuenta que el pod desplegado temporalmente se conecta al servicio de tipo IP del equilibrador de carga para probar la conectividad.
Enfoque 2: Desde su computadora local
- Ejecute el siguiente comando para probar la conectividad a la aplicación NGINX de prueba con el servicio de tipo equilibrador de carga desde nuestro portátil local.
```
iwhooge@iwhooge-mac ~ % wget -qO- <ip-of-internal-lb-service>
```
  Como notará, esto no funciona actualmente, ya que el servicio de tipo equilibrador de carga tiene una dirección IP interna y solo se puede acceder a él dentro del entorno de Kubernetes.
- Ejecute el siguiente comando para intentar acceder a la aplicación NGINX mediante la dirección IP local con un puerto personalizado 8080.
```
iwhooge@iwhooge-mac ~ % wget -qO- 127.0.0.1:8080
iwhooge@iwhooge-mac ~ %
```
  Por ahora, esto no funciona, pero usaremos el mismo comando más adelante en este tutorial después de configurar el túnel SSH.
La siguiente imagen ilustra el despliegue que hemos realizado hasta ahora. Tenga en cuenta que la conexión tunelizada a la dirección IP local no funciona.

Tarea 3: Creación de un script de configuración SSH con entradas de host local

Para permitir que funcione el túnel SSH, debemos agregar la siguiente entrada en nuestro archivo de configuración SSH ubicado en la carpeta /Users/iwhooge/.ssh.

Ejecute el comando nano /Users/iwhooge/.ssh/config para editar el archivo de configuración.
Agregue la siguiente línea en la sección Host operator47.
```
LocalForward 8080 127.0.0.1:8080
```

Salida del archivo de configuración de SSH.

iwhooge@iwhooge-mac .ssh % pwd
/Users/iwhooge/.ssh

iwhooge@iwhooge-mac .ssh % more config
Host bastion47
    HostName 129.xxx.xxx.xxx
    user opc
    IdentityFile ~/.ssh/id_rsa
    UserKnownHostsFile /dev/null
    StrictHostKeyChecking=no
    TCPKeepAlive=yes
    ServerAliveInterval=50

Host operator47
    HostName 10.0.0.11
    user opc
    IdentityFile ~/.ssh/id_rsa
    ProxyJump bastion47
    UserKnownHostsFile /dev/null
    StrictHostKeyChecking=no
    TCPKeepAlive=yes
    ServerAliveInterval=50
    LocalForward 8080 127.0.0.1:8080
iwhooge@iwhooge-mac .ssh %

Tenga en cuenta que el comando LocalForward se agrega al archivo de configuración SSH.

Tarea 4: Configuración del túnel SSH y conexión al servidor web NGINX mediante Localhost

Si está conectado con SSH al operador, desconecte esa sesión.
1. Vuelva a conectarse al operador con la secuencia de comandos.
```
iwhooge@iwhooge-mac ~ % ssh operator47
```
2. Ejecute el siguiente comando para obtener la dirección IP del servicio de equilibrador de carga interno.
```
[opc@o-sqrtga ~]$ kubectl get svc
```
3. Ejecute el siguiente comando en el operador (ventana SSH) para configurar el túnel SSH y reenviar todo el tráfico que va al host local 8080 al servicio del tipo de equilibrador de carga 80. El servicio de tipo equilibrador de carga reenviará el tráfico finalmente a la aplicación NGINX.
```
[opc@o-sqrtga ~]$ k port-forward svc/my-nginx-svc 8080:80
```
  Observe los mensajes Forwarding en la ventana SSH que indica que el puerto de host local 8080 se reenvía al puerto 80.
```
Forwarding from 127.0.0.1:8080 -> 80
Forwarding from [::1]:8080 -> 80
```
Pruebe la conectividad desde el equipo local y verifique si la conectividad funciona con una dirección IP local (127.0.0.1) con el puerto 8080 y compruebe si eso le permitirá conectarse a la aplicación NGINX dentro del entorno de OKE.
Abra un nuevo terminal y ejecute el siguiente comando para probar la conectividad.
```
iwhooge@iwhooge-mac ~ % wget -qO- 127.0.0.1:8080
```

Observe que obtendrá la siguiente salida en el terminal de su computadora local, lo que significa que está funcionando.

iwhooge@iwhooge-mac ~ % wget -qO- 127.0.0.1:8080
<!DOCTYPE html>
<html>
<head>
<title>Welcome to nginx!</title>
<style>
html { color-scheme: light dark; }
body { width: 35em; margin: 0 auto;
font-family: Tahoma, Verdana, Arial, sans-serif; }
</style>
</head>
<body>
<h1>Welcome to nginx!</h1>
<p>If you see this page, the nginx web server is successfully installed and
working. Further configuration is required.</p>

<p>For online documentation and support please refer to
<a href="http://nginx.org/">nginx.org</a>.<br/>
Commercial support is available at
<a href="http://nginx.com/">nginx.com</a>.</p>

<p><em>Thank you for using nginx.</em></p>
</body>
</html>
iwhooge@iwhooge-mac ~ %

En la ventana SSH del operador, observe que la salida ha cambiado y se ha agregado una nueva línea Handling connection for 8080.
Una prueba rápida con un explorador web muestra la siguiente salida.
La siguiente imagen ilustra el despliegue que hemos realizado hasta ahora. Tenga en cuenta que la conexión en túnel a la dirección IP local está funcionando.

Tarea 5: Despliegue de un servicio de MySQL Database en el cluster de Kubernetes

Podemos acceder a la aplicación NGINX a través del túnel SSH, ahora agregue un servicio de base de datos MySQL que se esté ejecutando dentro del entorno de OKE.

Para configurar un servicio de base de datos MySQL dentro de un entorno de Kubernetes, debe crear:
- Un secreto para la protección con contraseña.
- Un volumen persistente y una solicitud de volumen persistente para el almacenamiento de base de datos.
- Servicio de base de datos MYSQL con un servicio de tipo equilibrador de carga.

Ejecute los siguientes comandos para:

Cree la contraseña para el servicio de base de datos MySQL.

nano mysql-secret.yaml

Copie el siguiente código YAML en mysql-secret.yaml.

apiVersion: v1
kind: Secret
metadata:
  name: mysql-secret
type: kubernetes.io/basic-auth
stringData:
  password: Or@cle1

Aplique el código YAML.
```
kubectl apply -f mysql-secret.yaml
```

Cree el almacenamiento para el servicio de base de datos MySQL.

nano mysql-storage.yaml

Copie el siguiente código YAML en mysql-storage.yaml.

apiVersion: v1
kind: PersistentVolume
metadata:
  name: mysql-pv-volume
  labels:
    type: local
spec:
  storageClassName: manual
  capacity:
    storage: 20Gi
  accessModes:
    - ReadWriteOnce
  hostPath:
    path: "/mnt/data"
---
apiVersion: v1
kind: PersistentVolumeClaim
metadata:
  name: mysql-pv-claim
spec:
  storageClassName: manual
  accessModes:
    - ReadWriteOnce
  resources:
    requests:
      storage: 20Gi

Aplique el código YAML.
```
kubectl apply -f mysql-storage.yaml
```

Cree el servicio de base de datos MySQL y el servicio de tipo equilibrador de carga.

nano mysql-deployment.yaml

Copie el siguiente código YAML en mysql-deployment.yaml.

apiVersion: apps/v1
kind: Deployment
metadata:
  name: mysql
spec:
  selector:
    matchLabels:
      app: mysql
  strategy:
    type: Recreate
  template:
    metadata:
      labels:
        app: mysql
    spec:
      containers:
      - image: mysql:latest
        name: mysql
        env:
        - name: MYSQL_ROOT_PASSWORD
          valueFrom:
            secretKeyRef:
              name: mysql-secret
              key: password
        ports:
        - containerPort: 3306
          name: mysql
        volumeMounts:
        - name: mysql-persistent-storage
          mountPath: /var/lib/mysql
      volumes:
      - name: mysql-persistent-storage
        persistentVolumeClaim:
          claimName: mysql-pv-claim
---
apiVersion: v1
kind: Service
metadata:
  name: my-mysql-svc
  labels:
    app: mysql
  annotations:
    oci.oraclecloud.com/load-balancer-type: "lb"
    service.beta.kubernetes.io/oci-load-balancer-internal: "true"
    service.beta.kubernetes.io/oci-load-balancer-subnet1: "ocid1.subnet.oc1.me-abudhabi-1.aaaaaaaaguwakvc6xxxxxxxxxxxxxxxxxxxxxx2rseu7rixvdf5urvpxldhya"
    service.beta.kubernetes.io/oci-load-balancer-shape: "flexible"
    service.beta.kubernetes.io/oci-load-balancer-shape-flex-min: "50"
    service.beta.kubernetes.io/oci-load-balancer-shape-flex-max: "100"
spec:
  type: LoadBalancer
  ports:
  - port: 3306
  selector:
    app: mysql

Aplique el código YAML.
```
kubectl apply -f mysql-deployment.yaml
```
Verifique si el servicio de base de datos MySQL se ha desplegado correctamente.
```
kubectl get pod
```
Tenga en cuenta que el servicio de base de datos MySQL se ha desplegado correctamente.
Verifique si el servicio de tipo equilibrador de carga se ha desplegado correctamente.
```
kubectl get svc
```
Tenga en cuenta que el servicio de tipo equilibrador de carga se ha desplegado correctamente.

Para verificar el objeto del equilibrador de carga en la consola de OCI, vaya a Networking, Load Balancer y haga clic en el equilibrador de carga.
Para acceder a la consola de terminal del servicio de base de datos MySQL, podemos utilizar el comando kubectl exec y el comando de túnel SSH de host local.
1. Ejecute el siguiente comando para acceder a la consola de terminal desde el operador.
```
kubectl exec --stdin --tty mysql-74f8bf98c5-bl8vv -- /bin/bash
```
2. Ejecute el siguiente comando para acceder a la consola del servicio de base de datos MySQL.
```
mysql -p
```
3. Introduzca la contraseña especificada en el archivo mysql-secret.yaml y observe el mensaje de bienvenida del servicio de base de datos MySQL.
4. Ejecute la siguiente consulta SQL para ver una lista de todas las bases de datos MySQL dentro del servicio de base de datos.
```
SHOW DATABASES;
```
Ahora acceda a la consola de gestión de servicios de base de datos MySQL desde el entorno de Kubernetes.
La siguiente imagen ilustra el despliegue que hemos realizado hasta ahora. Observe que se despliega el servicio MySQL con el servicio de tipo equilibrador de carga.

Tarea 6: Adición de entradas de host local adicionales dentro del script de configuración SSH

Agregue entradas de host local adicionales dentro del script de configuración SSH para acceder al nuevo servicio de base de datos MySQL.

Para permitir que el túnel SSH funcione para el servicio de base de datos MySQL, debemos agregar la siguiente entrada en nuestro archivo de configuración SSH ubicado en la carpeta /Users/iwhooge/.ssh.
Ejecute el comando nano /Users/iwhooge/.ssh/config para editar el archivo de configuración.
Agregue la siguiente línea en la sección Host operator47.
```
LocalForward 8306 127.0.0.1:8306
```

Salida del archivo de configuración de SSH.

Host bastion47
    HostName 129.xxx.xxx.xxx
    user opc
    IdentityFile ~/.ssh/id_rsa
    UserKnownHostsFile /dev/null
    StrictHostKeyChecking=no
    TCPKeepAlive=yes
    ServerAliveInterval=50
Host operator47
    HostName 10.0.0.11
    user opc
    IdentityFile ~/.ssh/id_rsa
    ProxyJump bastion47
    UserKnownHostsFile /dev/null
    StrictHostKeyChecking=no
    TCPKeepAlive=yes
    ServerAliveInterval=50
    LocalForward 8080 127.0.0.1:8080
    LocalForward 8306 127.0.0.1:8306

Tenga en cuenta que el comando LocalForward se agrega al archivo de configuración SSH.

Tarea 7: Configuración del túnel SSH y conexión a MySQL Database mediante Localhost

Para probar la conexión al servicio de base de datos MySQL desde la computadora local, debe descargar e instalar MySQL Workbench en la computadora local.
1. Abra de nuevo un nuevo terminal para el operador mediante la secuencia de comandos. Deje el otro terminal abierto.
```
iwhooge@iwhooge-mac ~ % ssh operator47
```
2. Ejecute el siguiente comando en la ventana SSH del operador para configurar el túnel SSH y reenviar todo el tráfico que va al host local 8306 al servicio del tipo de equilibrador de carga 3306. El servicio de tipo equilibrador de carga reenviará el tráfico finalmente al servicio de base de datos MySQL.
```
[opc@o-sqrtga ~]$ k port-forward svc/my-mysql-svc 8306:3306
```
3. Observe los mensajes Forwarding en la ventana SSH que indica que el puerto de host local 8306 se reenvía al puerto 3306.
```
Forwarding from 127.0.0.1:8306 -> 3306
Forwarding from [::1]:8306 -> 3306
```
Se instala la aplicación MySQL Workbench y se establecen la sesión SSH y el túnel. Abra la aplicación MySQL Workbench en la computadora local.
Haga clic en + para agregar una nueva conexión MySQL.
En Configurar nueva conexión, introduzca la siguiente información.
1. Nombre de conexión: introduzca un nombre.
2. Nombre de host: introduzca la dirección IP que será 127.0.0.1 (localhost, ya que estamos estableciendo un túnel del tráfico).
3. Puerto: introduzca el puerto que será 8306, el puerto que utilizamos para el reenvío del túnel local para el servicio de base de datos MySQL.
4. Haga clic en Probar conexión.
1. Contraseña: introduzca la contraseña especificada en el archivo mysql-secret.yaml.
2. Haga clic en Aceptar.
Haga clic en Continuar de todas formas para ignorar la advertencia de conexión. Esta advertencia se proporciona porque la versión de la aplicación MySQL Workbench y la versión del servicio de base de datos MySQL desplegada pueden no ser compatibles.
1. Observe el mensaje de conexión correcta.
2. Haga clic en Aceptar.
3. Haga clic en Aceptar para guardar la conexión MySQL.
Haga clic en la conexión MySQL guardada para abrir la sesión.
Observe el mensaje Please stand by....
Haga clic en Continuar de todas formas para ignorar la advertencia de conexión.
1. Ejecute la siguiente consulta SQL para definir una lista de todas las bases de datos MySQL dentro del servicio de base de datos.
```
SHOW DATABASES;
```
2. Haga clic en el icono de relámpago.
3. Observe la salida de todas las bases de datos MySQL dentro del servicio de base de datos MySQL.
En la ventana SSH del operador, observe que la salida ha cambiado y se ha agregado una nueva línea Handling connection for 8306.
Hay varias entradas porque hemos realizado varias conexiones, una cada una para:
- Probar.
- Conexión real.
- Consulta SQL.
- Prueba que hicimos antes (adicional).
Ahora podemos abrir varias sesiones SSH hacia el operador y ejecutar varios comandos de túnel para diferentes aplicaciones simultáneamente. Observe las siguientes ventanas.
1. Terminal SSH con el comando de túnel para el servicio de base de datos MySQL.
2. Conexión mediante la aplicación MYSQL Workbench desde la computadora local al servicio de base de datos MySQL mediante la dirección IP del host local 127.0.0.1.
3. Terminal SSH con el comando de túnel para la aplicación NGINX.
4. Conexión mediante el explorador de Internet de Safari desde el equipo local a la aplicación NGINX mediante la dirección IP de host local 127.0.0.1.
La siguiente imagen ilustra el despliegue que hemos realizado hasta ahora. Tenga en cuenta que la conexión en túnel a la dirección IP local funciona para la aplicación NGINX y el servicio de base de datos MySQL simultáneamente con el uso de varias sesiones SSH y túneles SSH.

Tarea 8: Limpiar todas las aplicaciones y servicios

Ejecute los siguientes comandos para limpiar la aplicación NGINX desplegada y el servicio asociado.

kubectl get pods
kubectl delete service my-nginx-svc -n default
kubectl get pods
kubectl get svc
kubectl delete deployment my-nginx --namespace default
kubectl get svc

Ejecute los siguientes comandos para limpiar el servicio de base de datos MySQL desplegado y el servicio, el almacenamiento y la contraseña asociados.
```
kubectl delete deployment,svc mysql
kubectl delete pvc mysql-pv-claim
kubectl delete pv mysql-pv-volume
kubectl delete secret mysql-secret
```
En la siguiente imagen se ilustra el despliegue que hemos realizado hasta ahora, donde se vuelve a tener un entorno limpio y se puede volver a empezar.

Pasos Siguientes

La protección del acceso a los clusters de OKE es un paso fundamental en el desarrollo moderno de aplicaciones, y la creación de túneles SSH proporciona una solución sólida y sencilla. Al implementar los pasos de este tutorial, los desarrolladores pueden proteger sus recursos, optimizar sus flujos de trabajo y mantener el control sobre las conexiones confidenciales para varias aplicaciones. La integración del túnel SSH en la configuración de OKE no solo mejora la seguridad, sino que también minimiza los riesgos asociados con la exposición de recursos a la red pública de Internet. Con estas prácticas, puede utilizar con confianza sus clusters de OKE y centrarse en la creación de aplicaciones escalables, seguras y eficientes.

Agradecimientos

Autor: Iwan Hoogendoorn (especialista en red de OCI)

Más recursos de aprendizaje

Explore otros laboratorios en docs.oracle.com/learn o acceda a más contenido de formación gratuita en el canal YouTube de Oracle Learning. Además, visita education.oracle.com/learning-explorer para convertirte en un Oracle Learning Explorer.

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

Título e Información de Copyright

Leverage SSH Tunneling with Oracle Cloud Infrastructure Kubernetes Engine for Secure Application Development

G21948-02

December 2024

Oracle y/o sus filiales.