GSP1121

Descripción general

Kubernetes es uno de los métodos que más usan los profesionales de la nube para implementar aplicaciones. Probablemente hayas usado una solución de Kubernetes administrada para implementar aplicaciones en tu organización. Estas son algunas de las preguntas clave que surgen cuando se usa Kubernetes para implementar y alojar aplicaciones:

• ¿Qué servicio de balanceo de cargas requiere la app?
• ¿Cómo se administrará la infraestructura subyacente?

En Azure, Azure Kubernetes Service (AKS) administra la infraestructura subyacente para Pods, nodos y redes, gestiona la capa de acceso entre componentes y proporciona los servicios de Kubernetes para respaldar el ciclo de vida de las aplicaciones.

Probablemente hayas implementado aplicaciones en Azure AKS a través de la línea de comandos con Azure CLI y kubectl. La solución administrada de Kubernetes de Google Cloud, Google Kubernetes Engine (GKE), ofrece las mismas funciones que AKS. Puedes utilizar los mismos comandos de la CLI y kubectl con GKE y AKS.

En este lab, aprenderás a hacer lo siguiente:

• Usar Kubernetes Engine para aprovisionar un clúster completo de Kubernetes
• Usar kubectl para implementar y administrar contenedores de Docker
• Usar las implementaciones y los servicios de Kubernetes para dividir una aplicación en microservicios

Kubernetes se basa en aplicaciones. En esta parte del lab, usarás una aplicación de ejemplo llamada “app”.

Nota: La app se aloja en GitHub y proporciona una aplicación de ejemplo de 12 factores. Durante este lab, trabajarás con las siguientes imágenes de contenedor:

kelseyhightower/monolith: Monolith incluye los servicios auth y hello

kelseyhightower/auth: Microservicio auth; genera tokens JWT para los usuarios autenticados

kelseyhightower/hello: Microservicio hello; saluda a los usuarios autenticados

nginx: Frontend de los servicios auth y hello

Kubernetes es un proyecto de código abierto (disponible en kubernetes.io) que se puede ejecutar en distintos entornos, desde laptops hasta clústeres de múltiples nodos de alta disponibilidad, desde nubes públicas hasta implementaciones locales, desde máquinas virtuales hasta equipos físicos.

En este lab, usar un entorno administrado como Kubernetes Engine te permite concentrarte en experimentar con Kubernetes en vez de en configurar la infraestructura subyacente.

Configuración y requisitos

Antes de hacer clic en el botón Comenzar lab

Lee estas instrucciones. Los labs son cronometrados y no se pueden pausar. El cronómetro, que comienza a funcionar cuando haces clic en Comenzar lab, indica por cuánto tiempo tendrás a tu disposición los recursos de Google Cloud.

Este lab práctico te permitirá realizar las actividades correspondientes en un entorno de nube real, no en uno de simulación o demostración. Para ello, se te proporcionan credenciales temporales nuevas que utilizarás para acceder a Google Cloud durante todo el lab.

Para completar este lab, necesitarás lo siguiente:

• Acceso a un navegador de Internet estándar (se recomienda el navegador Chrome)

Nota: Usa una ventana de navegador privada o de Incógnito para ejecutar este lab. Así evitarás cualquier conflicto entre tu cuenta personal y la cuenta de estudiante, lo que podría generar cargos adicionales en tu cuenta personal.

• Tiempo para completar el lab: Recuerda que, una vez que comienzas un lab, no puedes pausarlo.

Nota: Si ya tienes un proyecto o una cuenta personal de Google Cloud, no los uses en este lab para evitar cargos adicionales en tu cuenta.

Cómo iniciar su lab y acceder a la consola de Google Cloud

1. Haga clic en el botón Comenzar lab. Si debe pagar por el lab, se abrirá una ventana emergente para que seleccione su forma de pago. A la izquierda, se encuentra el panel Detalles del lab que tiene estos elementos:

   • El botón Abrir la consola de Google
   • Tiempo restante
   • Las credenciales temporales que debe usar para el lab
   • Otra información para completar el lab, si es necesaria

2. Haga clic en Abrir la consola de Google. El lab inicia recursos y abre otra pestaña en la que se muestra la página de acceso.

   Sugerencia: Ordene las pestañas en ventanas separadas, una junto a la otra.

   Nota: Si ve el diálogo Elegir una cuenta, haga clic en Usar otra cuenta.

3. Si es necesario, copie el nombre de usuario del panel Detalles del lab y péguelo en el cuadro de diálogo Acceder. Haga clic en Siguiente.

4. Copie la contraseña del panel Detalles del lab y péguela en el cuadro de diálogo de bienvenida. Haga clic en Siguiente.

   Importante: Debe usar las credenciales del panel de la izquierda. No use sus credenciales de Google Cloud Skills Boost. Nota: Usar su propia Cuenta de Google podría generar cargos adicionales.

5. Haga clic para avanzar por las páginas siguientes:

   • Acepte los términos y condiciones.
   • No agregue opciones de recuperación o autenticación de dos factores (esta es una cuenta temporal).
   • No se registre para obtener pruebas gratuitas.

Después de un momento, se abrirá la consola de Cloud en esta pestaña.

Nota: Para ver el menú con una lista de los productos y servicios de Google Cloud, haga clic en el Menú de navegación que se encuentra en la parte superior izquierda de la pantalla.

Activa Cloud Shell

Cloud Shell es una máquina virtual que cuenta con herramientas para desarrolladores. Ofrece un directorio principal persistente de 5 GB y se ejecuta en Google Cloud. Cloud Shell proporciona acceso de línea de comandos a tus recursos de Google Cloud.

1. Haz clic en Activar Cloud Shell en la parte superior de la consola de Google Cloud.

Cuando te conectes, habrás completado la autenticación, y el proyecto estará configurado con tu PROJECT_ID. El resultado contiene una línea que declara el PROJECT_ID para esta sesión:

Your Cloud Platform project in this session is set to YOUR_PROJECT_ID

gcloud es la herramienta de línea de comandos de Google Cloud. Viene preinstalada en Cloud Shell y es compatible con la función de autocompletado con tabulador.

2. Puedes solicitar el nombre de la cuenta activa con este comando (opcional):

gcloud auth list

3. Haz clic en Autorizar.

4. Ahora, el resultado debería verse de la siguiente manera:

Resultado:

ACTIVE: * ACCOUNT: student-01-xxxxxxxxxxxx@qwiklabs.net To set the active account, run: $ gcloud config set account `ACCOUNT`

5. Puedes solicitar el ID del proyecto con este comando (opcional):

gcloud config list project

Resultado:

[core] project = <project_ID>

Resultado de ejemplo:

[core] project = qwiklabs-gcp-44776a13dea667a6 Nota: Para obtener toda la documentación de gcloud, consulta la guía con la descripción general de gcloud CLI en Google Cloud.

Google Kubernetes Engine

1. En Cloud Shell, escribe el siguiente comando para establecer la zona:

gcloud config set compute/zone {{{ project_0.default_zone | "ZONE" }}}

2. Inicia un clúster para usarlo en este lab con el siguiente comando:

gcloud container clusters create io Tras la creación, se te autentica automáticamente en tu clúster. Si pierdes conexión con Cloud Shell por cualquier motivo, ejecuta el comando gcloud container clusters get-credentials io para volver a autenticarte. Nota: Llevará un tiempo crear un clúster, ya que Kubernetes Engine aprovisiona unas pocas máquinas virtuales en segundo plano para que practiques con ellas.

Tarea 1: Obtén el código de muestra

1. En Cloud Shell, ingresa el siguiente comando para clonar el repositorio en el entorno de Cloud Shell del lab.

git clone https://github.com/GoogleCloudPlatform/training-data-analyst

2. Crea un vínculo simbólico como un acceso directo al directorio de trabajo:

   ln -s ~/training-data-analyst/courses/ak8s/CloudBridge ~/ak8s

3. Cambia al directorio necesario para este lab con este comando:

   cd ~/ak8s/

4. Solicita una lista de los archivos con los que trabajarás:

ls

La muestra tiene el siguiente diseño:

deployments/ /* Deployment manifests */ ... nginx/ /* nginx config files */ ... pods/ /* Pod manifests */ ... services/ /* Services manifests */ ... tls/ /* TLS certificates */ ... cleanup.sh /* Cleanup script */

Ya puedes usar el código para probar Kubernetes.

Tarea 2: Haz una demostración rápida de Kubernetes

La forma más fácil de comenzar a usar Kubernetes es utilizar el comando kubectl create.

1. Úsalo para iniciar una sola instancia del contenedor nginx:

kubectl create deployment nginx --image=nginx:1.10.0

Kubernetes ya creó una implementación; hablaremos sobre ellas más adelante. Por el momento, todo lo que necesitas saber es que las implementaciones mantienen a los Pods en funcionamiento, incluso cuando fallan los nodos en los que se ejecutan.

En Kubernetes, todos los contenedores se ejecutan en un Pod.

2. Usa el comando kubectl get pods para ver el contenedor nginx en ejecución:

kubectl get pods

3. Una vez que el contenedor nginx alcance el estado Running, podrás exponerlo por fuera de Kubernetes con el comando kubectl expose:

kubectl expose deployment nginx --port 80 --type LoadBalancer

¿Qué acaba de suceder? En segundo plano, Kubernetes creó un balanceador de cargas externo vinculado a una dirección IP pública. Los clientes que accedan a esa dirección IP pública serán redirigidos a los Pods del servicio. En este caso, esto correspondería al Pod de nginx.

4. Crea una lista de nuestros servicios con el comando kubectl get services:

kubectl get services Nota: Pueden pasar unos segundos hasta que el campo ExternalIP se complete para el servicio. Esto es normal; solo vuelve a ejecutar el comando kubectl get services cada algunos segundos hasta que se complete el campo.

5. Para acceder al contenedor nginx de forma remota, agrega la IP externa a este comando:

curl http://<EXTERNAL-IP>:80

Listo. Kubernetes es compatible con un flujo de trabajo inmediato y fácil de usar mediante los comandos kubectl run y expose.

Prueba la tarea completada

Haz clic en Revisar mi progreso a continuación para revisar tu progreso en el lab. Si creaste un clúster de Kubernetes con éxito y también implementaste un contenedor Nginx, verás una puntuación de evaluación.

Crear un clúster de Kubernetes e iniciar el contendor nginx

Ahora que terminaste de revisar esta breve demostración de Kubernetes, es hora de profundizar en cada uno de los componentes y las abstracciones.

Tarea 3: Pods

Los Pods son uno de los conceptos centrales de Kubernetes.

Representan y contienen una colección de uno o más contenedores. Por lo general, si tienes varios contenedores que dependen fuertemente entre sí, los empaquetas en un solo Pod.

En este ejemplo, tenemos un Pod con los contenedores monolith y nginx.

Los Pods también tienen volúmenes. Son discos de datos que funcionan en tanto los Pods estén activos, y los pueden usar los contenedores del Pod correspondiente. Los Pods proporcionan un espacio de nombres compartido para sus contenidos. Esto significa que los dos contenedores de nuestro Pod de ejemplo se pueden comunicar entre sí y, además, comparten los volúmenes adjuntos.

Los Pods también comparten un espacio de nombres de red, lo que significa que hay una dirección IP por Pod.

A continuación, profundizaremos en los Pods.

Tarea 4: Crea Pods

Los Pods se pueden crear con archivos de configuración de Pod. Dedica un momento a explorar el archivo de configuración del Pod monolith.

1. Ve al siguiente directorio:

cd ~/ak8s

2. Ejecuta lo siguiente:

cat pods/monolith.yaml

El resultado muestra el archivo de configuración abierto:

apiVersion: v1 kind: Pod metadata: name: monolith labels: app: monolith spec: containers: - name: monolith image: kelseyhightower/monolith:1.0.0 args: - "-http=0.0.0.0:80" - "-health=0.0.0.0:81" - "-secret=secret" ports: - name: http containerPort: 80 - name: health containerPort: 81 resources: limits: cpu: 0.2 memory: "10Mi"

Observa lo siguiente:

• Que tu Pod conste de un contenedor (monolith)
• Que cuando se inicie el contenedor, se le pasen algunos argumentos
• Que abras el puerto 80 para el tráfico HTTP

3. Usa kubectl para crear el Pod monolith:

kubectl create -f pods/monolith.yaml

4. Examina tus Pods. Usa el comando kubectl get pods para obtener una lista de todos los Pods que se ejecutan en el espacio de nombres predeterminado:

kubectl get pods Nota: El Pod monolith puede tardar unos segundos en empezar a ejecutarse. Se debe extraer la imagen del contenedor monolith desde Docker Hub antes de poder ejecutarlo.

5. Para obtener más información sobre el Pod monolith, usa el comando kubectl describe cuando se ejecute el Pod:

kubectl describe Pods monolith

Verás mucha información sobre el Pod monolith, como su dirección IP y el registro de eventos. Esta información será de utilidad para solucionar problemas.

Con Kubernetes, es fácil crear Pods con solo describirlos en los archivos de configuración y también es fácil ver información sobre ellos mientras se ejecutan. En este momento, tienes la capacidad de crear todos los Pods que requiera tu implementación .

Tarea 5: Interactúa con los Pods

De forma predeterminada, los Pods reciben una dirección IP privada a la que no se puede acceder desde fuera del clúster. Usa el comando kubectl port-forward para asignar un puerto local a un puerto dentro del Pod monolith.

Nota: A partir de este punto del lab, deberás trabajar en varias pestañas de Cloud Shell para configurar la comunicación entre Pods. Cuando algún comando deba ejecutarse en una segunda o tercera shell de comandos, se indicará en las instrucciones.

1. Abre una segunda terminal de Cloud Shell. Ahora tienes dos terminales, una para ejecutar el comando kubectl port-forward y otra para emitir comandos curl.

2. Para configurar la redirección de puertos, ejecuta el siguiente comando en la segunda terminal:

kubectl port-forward monolith 10080:80

3. Ahora, usa el comando curl en la primera terminal para empezar a comunicarte con el Pod:

curl http://127.0.0.1:10080

¡Perfecto! Recibiste un amigable saludo de tu contenedor.

4. A continuación, usa el comando curl para ver qué sucede cuando accedes a un extremo seguro:

curl http://127.0.0.1:10080/secure

¡Uy!

5. Intenta acceder para que monolith te proporcione un token de auth:

curl -u user http://127.0.0.1:10080/login

6. En la ventana de acceso, usa la contraseña supersecreta “password”.

El hecho de acceder hace que se genere un token JWT.

7. Crea una variable de entorno para el token, ya que Cloud Shell no copia bien las cadenas largas.

TOKEN=$(curl http://127.0.0.1:10080/login -u user|jq -r '.token')

8. Ingresa nuevamente la contraseña supersecreta “password” cuando se te solicite la contraseña del host.

9. Usa el siguiente comando para copiar el token y usarlo para acceder el extremo seguro con curl:

curl -H "Authorization: Bearer $TOKEN" http://127.0.0.1:10080/secure

En este punto, deberías recibir una respuesta de nuestra aplicación para informarte que todo funciona como corresponde nuevamente.

10. Usa el comando kubectl logs para ver los registros del Pod monolith.

kubectl logs monolith

11. Abre una tercera terminal y usa la marca -f para obtener una transmisión de los registros en tiempo real:

kubectl logs -f monolith

12. Si usas curl en la primera terminal para interactuar con monolith, verás que se actualizan los registros ubicados en la tercera terminal:

curl http://127.0.0.1:10080

13. Usa el comando kubectl exec para ejecutar una shell interactiva dentro del Pod monolith, lo que puede ser útil para solucionar problemas en un contenedor:

kubectl exec monolith --stdin --tty -c monolith -- /bin/sh

14. Por ejemplo, una vez que tienes una shell en el contenedor monolith, puedes usar el comando ping para probar la conectividad externa:

ping -c 3 google.com

15. Asegúrate de salir cuando termines de usar esta shell interactiva.

exit

Como puedes ver, interactuar con los Pods es tan sencillo como usar el comando kubectl. Kubernetes proporciona todo lo que necesitas para comenzar a usar el servicio, ya sea que necesites obtener una shell de acceso o acceder a un contenedor de forma remota.

Tarea 6: Services

Los Pods no están diseñados para ser persistentes. Pueden detenerse o iniciarse por diversos motivos, como verificaciones de funcionamiento y preparación fallidas, lo que genera el siguiente problema:

¿Qué sucede si deseas comunicarte con un conjunto de Pods? Es posible que la dirección IP cambie cuando se reinicien.

Ahora es cuando los Services cobran importancia, ya que proporcionan extremos estables para los Pods.

Los Services usan etiquetas para determinar en qué Pods operan. Si los Pods tienen las etiquetas correctas, nuestros servicios los seleccionan y exponen automáticamente.

El tipo de servicio determina el nivel de acceso que proporciona a un conjunto de Pods. Estos son los tres tipos disponibles actualmente:

• ClusterIP (interno): Este tipo predeterminado significa que el servicio solo se puede ver dentro del clúster.
• NodePort: Proporciona una IP accesible de forma externa a cada nodo del clúster.
• LoadBalancer: Agrega un balanceador de cargas del proveedor de servicios en la nube que reenvía el tráfico del servicio a los nodos que contiene.

A continuación, aprenderás lo siguiente:

• Cómo crear un servicio
• Cómo usar los selectores de etiquetas para exponer de forma externa un conjunto limitado de Pods

Tarea 7: Crea un Service

Antes de poder crear Services, primero crea un Pod seguro que pueda manejar el tráfico HTTPS.

1. Si cambiaste de directorio, asegúrate de volver al directorio ~/orchestrate-with-kubernetes/kubernetes:

cd ~/ak8s

2. Explora el archivo de configuración del Service de monolith con el siguiente comando:

cat pods/secure-monolith.yaml

3. Crea los Pods secure-monolith y sus datos de configuración:

kubectl create secret generic tls-certs --from-file tls/ kubectl create configmap nginx-proxy-conf --from-file nginx/proxy.conf kubectl create -f pods/secure-monolith.yaml

Ahora que tienes un Pod seguro, es hora de exponer de forma externa el Pod secure-monolith. Para ello, crea un Service de Kubernetes.

4. Explora el archivo de configuración del Service de monolith con el siguiente comando:

cat services/monolith.yaml

(Resultado):

kind: Service apiVersion: v1 metadata: name: "monolith" spec: selector: app: "monolith" secure: "enabled" ports: - protocol: "TCP" port: 443 targetPort: 443 nodePort: 31000 type: NodePort Aspectos que debes tener en cuenta:

* Hay un selector que se usa para buscar y exponer automáticamente cualquier Pod con las etiquetas `app: monolith` y `secure: enabled`.

* Ahora debes exponer el puerto del nodo aquí, ya que es la forma en que reenviarás el tráfico externo del puerto 31000 a nginx (en el puerto 443).

5. Usa el comando kubectl create para crear el Service monolith a partir del archivo de configuración correspondiente:

kubectl create -f services/monolith.yaml

(Resultado):

service/monolith created

Prueba la tarea completada

Haz clic en Revisar mi progreso a continuación para revisar tu progreso en el lab. Si creaste correctamente los Pods y el Service monolith, verás una puntuación de evaluación.

Crear los Pods y el Service monolith

Estás usando un puerto para exponer el servicio. Esto significa que es posible tener conflictos de puerto si otra aplicación intenta vincularse al puerto 31000 en uno de sus servidores.

Normalmente, Kubernetes se encarga de la asignación de puertos. En este lab, elegiste un puerto para configurar fácilmente las verificaciones de estado más adelante.

6. Usa el comando gcloud compute firewall-rules para permitir el tráfico hacia el Service monolith en el puerto de nodo expuesto:

gcloud compute firewall-rules create allow-monolith-nodeport \ --allow=tcp:31000

Prueba la tarea completada

Haz clic en Revisar mi progreso a continuación para revisar tu progreso en el lab. Si creaste con éxito una regla de firewall que permite el tráfico de TCP en el puerto 31000, verás una puntuación de evaluación.

Permitir el tráfico hacia el Service monolith en el puerto de nodo expuesto

Ahora que todo está configurado, deberías poder acceder al Service secure-monolith desde fuera del clúster sin usar la redirección de puertos.

1. Primero, obtén una dirección IP externa para uno de los nodos.

gcloud compute instances list

2. A continuación, usa el comando curl para acceder al Service secure-monolith:

curl -k https://<EXTERNAL-IP>:31000

Se agotó el tiempo de espera. ¿Cuál es el problema?

Nota: Es momento de realizar una verificación de conocimientos rápida.

Usa estos comandos para responder las siguientes preguntas:

kubectl get services monolith

kubectl describe services monolith

Preguntas:

¿Por qué no puedes obtener una respuesta del servicio monolith?

¿Cuántos extremos tiene el servicio monolith?

¿Qué etiquetas debe tener un Pod para que el servicio monolith lo seleccione?

Pista: La respuesta está relacionada con las etiquetas. Solucionarás el problema en la siguiente sección.

Tarea 8: Agrega etiquetas a los Pods

De momento, el Service monolith no cuenta con extremos. Una forma de solucionar un problema como este es usar el comando kubectl get pods con una consulta sobre etiquetas.

1. Puedes ver que hay pocos Pods ejecutándose con la etiqueta monolith.

kubectl get pods -l "app=monolith"

2. Sin embargo, ¿qué sucede con “app=monolith” y “secure=enabled”?

kubectl get pods -l "app=monolith,secure=enabled"

Observa que esta consulta sobre etiquetas no genera resultados. Parece que debes agregarles la etiqueta “secure=enabled”.

3. Usa el comando kubectl label para agregar la etiqueta faltante secure=enabled al Pod secure-monolith. A continuación, puedes verificar y revisar que se hayan actualizado las etiquetas.

kubectl label pods secure-monolith 'secure=enabled' kubectl get pods secure-monolith --show-labels

4. Ahora que los Pods están bien etiquetados, observa la lista de extremos en el Service monolith con este comando:

kubectl describe services monolith | grep Endpoints

Ya lograste obtener uno.

5. Para probarlo, vuelve a acceder a uno de los nodos.

gcloud compute instances list curl -k https://<EXTERNAL_IP>:31000

¡Excelente! Se estableció la conexión.

Prueba la tarea completada

Haz clic en Revisar mi progreso a continuación para revisar tu progreso en el lab. Si agregaste etiquetas con éxito a los Pods monolith, verás una puntuación de evaluación.

Agregar etiquetas a los Pods

Tarea 9: Implementa aplicaciones con Kubernetes

El objetivo de este lab es prepararte para escalar y administrar los contenedores en producción. Ahora es cuando los Deployments cobran importancia. Los Deployments son una forma declarativa de garantizar que la cantidad de Pods en ejecución sea igual a la cantidad deseada de Pods que especifica el usuario.

La ventaja principal de los Deployments es abstraer los detalles de bajo nivel de la administración de los Pods. En segundo plano, los Deployments usan conjuntos de réplicas para administrar el inicio y la detención de los Pods. Un objeto Deployment permite actualizar o escalar los Pods si es necesario, así como reiniciar los Pods si estos se desconectan por algún motivo.

Observa un ejemplo breve:

Los Pods están sujetos al ciclo de vida del nodo en el que se crearon. En el ejemplo anterior, Node3 se desconectó, por lo que también se desconectó un Pod. En vez de crear un Pod nuevo de forma manual y buscar un nodo para él, el Deployment creó un Pod nuevo y lo inició en Node2.

Eso es muy práctico.

Es momento de aplicar todo lo que aprendiste sobre los Pods y Services para dividir la aplicación monolith en Services más pequeños a través de Deployments.

Tarea 10: Crea implementaciones

Dividirás la app monolith en tres partes:

• auth: Genera tokens JWT para usuarios autenticados.
• hello: Saluda a los usuarios autenticados.
• frontend: Enruta el tráfico hacia los servicios auth y hello.

Ya cuentas con lo necesario para crear Deployments, uno por Service. Luego de esto, definirás los Services internos para los Deployments auth y hello, además de un Service externo destinado al Deployment del frontend. Una vez que termines, podrás interactuar con los microservicios al igual que con monolith, solo que ahora podrás implementar y escalar cada parte de forma independiente.

1. Empieza por examinar el archivo de configuración del Deployment auth.

cat deployments/auth.yaml

(Resultado)

apiVersion: apps/v1 kind: Deployment metadata: name: auth spec: selector: matchlabels: app: auth replicas: 1 template: metadata: labels: app: auth track: stable spec: containers: - name: auth image: "kelseyhightower/auth:2.0.0" ports: - name: http containerPort: 80 - name: health containerPort: 81 ...

El Deployment creará 1 réplica, y estás usando la versión 2.0.0. del contenedor auth.

Cuando ejecutes el comando kubectl create para crear el Deployment auth, se creará un Pod que se ajusta a los datos del manifiesto de Deployment. Esto significa que puedes escalar la cantidad de Pods con solo modificar la cantidad especificada en el campo “Replicas”.

2. De cualquiera manera, crea tu objeto Deployment con el comando siguiente:

kubectl create -f deployments/auth.yaml

3. Es hora de crear un Service para tu Deployment auth. Usa el comando kubectl create para crear el servicio auth:

kubectl create -f services/auth.yaml

4. Ahora, haz lo mismo para crear y exponer el Deployment hello:

kubectl create -f deployments/hello.yaml kubectl create -f services/hello.yaml

5. Y haz lo mismo una vez más para crear y exponer el Deployment frontend.

kubectl create configmap nginx-frontend-conf --from-file=nginx/frontend.conf kubectl create -f deployments/frontend.yaml kubectl create -f services/frontend.yaml Note: Hay un paso más que debes seguir para crear el frontened porque necesitas almacenar algunos datos de configuración con el contenedor.

6. Usa la IP externa del frontend y ejecuta el comando curl para interactuar con él:

kubectl get services frontend Nota: La dirección IP externa puede tardar un minuto en crearse. Ejecuta el comando anterior de nuevo si el estado de la columna EXTERNAL-IP es pending. curl -k https://<EXTERNAL-IP>

Recibirás un saludo como respuesta.

Prueba la tarea completada

Haz clic en Revisar mi progreso a continuación para revisar tu progreso en el lab. Si creaste con éxito los Deployments auth, hello y frontend, verás una puntuación de evaluación.

Crear Deployments (auth, hello y frontend)

¡Felicitaciones!

Desarrollaste una aplicación de varios servicios con Kubernetes. Las habilidades que aprendiste te permitirán usar una colección de Deployments y Services para implementar aplicaciones complejas en Kubernetes.

Analicemos las similitudes y diferencias que observaste durante el lab entre las dos plataformas.

Similitudes:

• El proceso de configuración y de implementación de una aplicación en GKE es muy similar al de Azure AKS.
• Ambos servicios utilizan comandos kubectl y aceptan Dockerfiles.
• Al igual que AKS, GKE administra la infraestructura subyacente y proporciona Services de Kubernetes.

Diferencias:

• A medida que continúes explorando el funcionamiento de GKE, notarás algunas diferencias con respecto a AKS. En concreto, GKE ofrece Autopilot, que proporciona una configuración optimizada según las prácticas recomendadas de Google.
• En términos de red, AKS utiliza la red virtual de Azure y la interfaz de red de contenedores de Azure. La interfaz de red de contenedores de Azure ayuda a proporcionar direcciones IP de red virtual para cada Pod y los Pods pueden acceder directamente a otros servicios que están bajo los extremos del servicio de red virtual. En Google Cloud, el modelo de herramientas de redes de Kubernetes se basa en gran medida en las direcciones IP. Los objetos Service, los Pods, los contenedores y los nodos se comunican mediante direcciones IP y puertos.

Finaliza la Quest

Este lab de autoaprendizaje forma parte de Build Google Cloud Infrastructure for Azure Professionals. Una Quest es una serie de labs relacionados que forman una ruta de aprendizaje. Si completas esta Quest, obtendrás una insignia como reconocimiento por tu logro. Puedes hacer públicas tus insignias y agregar vínculos a ellas en tu currículum en línea o en tus cuentas de redes sociales. Inscríbete en cualquier Quest que contenga este lab y obtén un crédito inmediato de finalización. Consulta el catálogo de Google Cloud Skills Boost para ver todas las Quests disponibles.

Completa el próximo lab

Continúa tu Quest con el lab Cómo alojar una aplicación web en Google Cloud mediante Compute Engine.

Próximos pasos/Más información

• Puede seguir las novedades de Kubernetes en X y en el blog de la comunidad.
• Recuerda que Kubernetes es un proyecto de código abierto (http://kubernetes.io/) alojado en GitHub. Tus comentarios y contribuciones son siempre bienvenidos.

Capacitación y certificación de Google Cloud

Recibe la formación que necesitas para aprovechar al máximo las tecnologías de Google Cloud. Nuestras clases incluyen habilidades técnicas y recomendaciones para ayudarte a avanzar rápidamente y a seguir aprendiendo. Para que puedas realizar nuestros cursos cuando más te convenga, ofrecemos distintos tipos de capacitación de nivel básico a avanzado: a pedido, presenciales y virtuales. Las certificaciones te ayudan a validar y demostrar tus habilidades y tu conocimiento técnico respecto a las tecnologías de Google Cloud.

Última actualización del manual: 30 de octubre de 2023

Prueba más reciente del lab: 30 de octubre de 2023

Copyright 2024 Google LLC. All rights reserved. Google y el logotipo de Google son marcas de Google LLC. Los demás nombres de productos y empresas pueden ser marcas de las respectivas empresas a las que estén asociados.