Puntos de control
Create a Kubernetes cluster
/ 5
Create the monolith pod
/ 5
Create the healthy-monolith pod
/ 5
Create a secret, service, firewall rule and pod with label
/ 5
Aspectos básicos de Kubernetes v1.6
Descripción general
En este lab, aprenderá a realizar lo siguiente:
- Aprovisionar un clúster de Kubernetes mediante Google Kubernetes Engine
- Usar
kubectlpara implementar y administrar contenedores de Docker - Usar las implementaciones y los servicios de Kubernetes para dividir una aplicación en microservicios
Usará Kubernetes Engine y su API de Kubernetes para implementar, administrar y actualizar aplicaciones. Asimismo, usará una aplicación de ejemplo llamada "app" para completar los labs.
Configuración
Paso 1
En cada lab, recibirá un proyecto de Google Cloud y un conjunto de recursos nuevos por tiempo limitado y sin costo adicional.
-
Accede a Qwiklabs desde una ventana de incógnito.
-
Ten en cuenta el tiempo de acceso del lab (por ejemplo,
1:15:00) y asegúrate de finalizarlo en el plazo asignado.
No existe una función de pausa. Si lo necesita, puede reiniciar el lab, pero deberá hacerlo desde el comienzo. -
Cuando esté listo, haga clic en Comenzar lab.
-
Anote las credenciales del lab (el nombre de usuario y la contraseña). Las usarás para acceder a la consola de Google Cloud.
-
Haga clic en Abrir Google Console.
-
Haga clic en Usar otra cuenta, copie las credenciales para este lab y péguelas en el mensaje emergente que aparece.
Si usa otras credenciales, se generarán errores o incurrirá en cargos. -
Acepta las condiciones y omite la página de recursos de recuperación.
Paso 2
Asegúrese de que las siguientes API estén habilitadas en Cloud Platform Console:
- API de Kubernetes Engine
- API de Container Registry
En el menú de navegación (
Desplácese por la lista y confirme que sus API estén habilitadas.
Si falta una API, haga clic en HABILITAR API Y SERVICIOS en la parte superior, busque la API por nombre y habilítela para su proyecto.
Paso 3
Activa Google Cloud Shell
Google 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.
Google Cloud Shell proporciona acceso de línea de comandos a tus recursos de Google Cloud.
-
En la consola de Cloud, en la barra de herramientas superior derecha, haz clic en el botón Abrir Cloud Shell.
-
Haz clic en Continuar.
El aprovisionamiento y la conexión al entorno demorarán unos minutos. Cuando te conectes, habrás completado la autenticación, y el proyecto estará configurado con tu PROJECT_ID. Por ejemplo:
gcloud es la herramienta de línea de comandos de Google Cloud. Viene preinstalada en Cloud Shell y es compatible con el completado de línea de comando.
- Puedes solicitar el nombre de la cuenta activa con este comando:
Resultado:
Resultado de ejemplo:
- Puedes solicitar el ID del proyecto con este comando:
Resultado:
Resultado de ejemplo:
Paso 4
Obtenga el código de muestra del repositorio de Git.
git clone https://github.com/googlecodelabs/orchestrate-with-kubernetes.git
Paso 5
Revise el diseño de la aplicación.
cd orchestrate-with-kubernetes/kubernetes
ls
Observará la siguiente estructura:
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
Ya puede usar su código para probar Kubernetes.
Una demostración rápida de Kubernetes
Inicie un clúster de Kubernetes
Paso 1
Defina su zona como una zona predeterminada del proyecto. De esta manera, no necesita especificar el parámetro --zone en los comandos de gcloud.
gcloud config set compute/zone us-central1-a
En Cloud Shell, ejecute el siguiente comando para iniciar un clúster de Kubernetes llamado bootcamp que ejecuta 5 nodos:
gcloud container clusters create bootcamp --num-nodes 5 --scopes "https://www.googleapis.com/auth/projecthosting,storage-rw"
El argumento scopes brinda acceso al alojamiento del proyecto y a las API de Google Cloud Storage que usará más adelante.
Haga clic en Revisar mi progreso para verificar el objetivo.
Paso 2
Una vez creado el clúster, verifique su versión instalada de Kubernetes mediante el comando kubectl version.
kubectl version
Paso 3
Use kubectl cluster-info para obtener más información sobre el clúster.
kubectl cluster-info
Paso 4
Vea sus nodos en ejecución en Cloud Platform Console.
Abra el menú de navegación y vaya a Compute Engine > Instancias de VM.
Compleción por bash (opcional)
Kubernetes viene con la función de autocompletar. Puede usar el comando kubectl completion y el comando incorporado source para configurarla.
Paso 1
Ejecute este comando:
source <(kubectl completion bash)
Paso 2
Presione Tab para mostrar una lista de los comandos disponibles.
Pruebe los siguientes ejemplos:
kubectl <TAB><TAB>
También puede completar un comando parcial:
kubectl co<TAB><TAB>
Esta función facilita aún más el uso de kubectl.
Implemente y ejecute un contenedor
La manera más fácil de comenzar a usar Kubernetes es mediante el comando kubectl create deployment.
Paso 1
Use kubectl create deployment para iniciar una sola instancia del contenedor nginx:
kubectl create deployment nginx --image=nginx:1.10.0
Paso 2
Use el comando kubectl get pods para ver el pod que ejecuta el contenedor nginx.
kubectl get pods
Paso 3
Use el comando kubectl expose para exponer el contenedor nginx fuera de Kubernetes.
kubectl expose deployment nginx --port 80 --type LoadBalancer
Paso 4
Use el comando kubectl get para ver el nuevo servicio.
kubectl get services
Verá una IP externa que puede usar para probar y contactar al contenedor nginx de forma remota.
Paso 5
Use el comando kubectl scale para escalar la cantidad de aplicaciones de backend (pods) que se ejecutan en su servicio mediante el siguiente código:
kubectl scale deployment nginx --replicas 3
Esta acción es útil cuando desea aumentar la carga de trabajo para una aplicación web que es cada vez más popular.
Paso 6
Obtenga los pods una vez más para confirmar que Kubernetes haya actualizado la cantidad de pods.
kubectl get pods
Paso 7
Vuelva a usar el comando kubectl get services para confirmar que su dirección IP externa no haya cambiado.
kubectl get services
Paso 8
Use la dirección IP externa con el comando curl para probar la demostración de su aplicación.
curl http://<External IP>:80
Kubernetes es compatible con un flujo de trabajo inmediato y fácil de usar mediante el uso de los comandos kubectl run, expose y scale.
Limpie
Ejecute los siguientes comandos para limpiar nginx:
kubectl delete deployment nginx
kubectl delete service nginx
Ahora que terminó de revisar esta breve demostración de Kubernetes, es momento de profundizar en cada uno de los componentes y las abstracciones.
Pods
Investigue los pods en mayor detalle.
Cómo crear pods
Los pods se pueden crear con archivos de configuración de pod.
Paso 1
Explore la documentación incorporada del pod con el comando kubectl explain:
kubectl explain pods
Paso 2
Explore el archivo de configuración del pod monolith.
cat pods/monolith.yaml
Paso 3
Use el comando kubectl explain con la opción .spec para obtener más información sobre los objetos de la API. Este ejemplo inspecciona los contenedores:
kubectl explain pods.spec.containers
Explore el resto de la API antes de continuar.
Paso 4
Cree el pod monolith con kubectl create:
kubectl create -f pods/monolith.yaml
Haga clic en Revisar mi progreso para verificar el objetivo.
Paso 5
Use 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
Paso 6
Cuando se ejecute el pod, use el comando kubectl describe para obtener más información sobre el pod monolith.
kubectl describe pods monolith
Verá mucha información sobre el pod monolith, como la dirección IP y el registro de acontecimientos. Esta información será útil cuando solucione problemas.
Como puede ver, con Kubernetes es fácil crear pods con solo describirlos en los archivos de configuración y ver información al respecto mientras se ejecutan. En este momento, puede crear todos los pods que requiera su implementación.
Cómo interactuar con los pods
De manera predeterminada, los pods reciben una dirección IP privada a la que no se puede acceder desde fuera del clúster. Use el comando kubectl port-forward para mapear un puerto local a un puerto dentro del pod monolith.
Use dos terminales: una para ejecutar el comando kubectl port-forward y la otra para ejecutar los comandos curl.
Paso 1
Haga clic en el botón + en Cloud Shell para abrir una nueva terminal.
Paso 2
Ejecute el siguiente comando para configurar la redirección de puertos desde un puerto local, 10080, a un puerto de pod, 80 (donde está escuchando su contenedor):
kubectl port-forward monolith 10080:80
Paso 3
Para acceder a su pod, regrese a la primera ventana de la terminal y ejecute el siguiente comando curl:
curl http://127.0.0.1:10080
Obtendrá un amigable "Hola" del contenedor.
Paso 4
Vea qué sucede cuando accede a un extremo seguro.
curl http://127.0.0.1:10080/secure
Debería ver un error.
Paso 5
Acceda para que monolith le proporcione un token de autenticación.
curl -u user http://127.0.0.1:10080/login
En el indicador de acceso, ingrese la contraseña como password para acceder.
Paso 6
Ya que Cloud Shell no copia bien las strings largas, copie el token en una variable de entorno.
TOKEN=$(curl http://127.0.0.1:10080/login -u user|jq -r '.token')
En el indicador de acceso, ingrese la contraseña como password para acceder.
Paso 7
Acceda al extremo seguro otra vez y, esta vez, incluya el token de autenticación.
curl -H "Authorization: Bearer $TOKEN" http://127.0.0.1:10080/secure
Paso 8
Use el comando kubectl logs para ver los registros del pod monolith.
kubectl logs monolith
Paso 9
Abra otra terminal y use la marca -f para obtener una secuencia de registros en tiempo real.
Para crear la tercera terminal, haga clic en el botón + en Cloud Shell y ejecute el siguiente comando:
kubectl logs -f monolith
Paso 10
Use curl en la terminal 1 para interactuar con monolith. Verá la actualización de los registros en la terminal 3.
curl http://127.0.0.1:10080
Paso 11
Use el comando kubectl exec para ejecutar una shell interactiva dentro del pod monolith. Esto puede ser útil para solucionar problemas en un contenedor.
kubectl exec monolith --stdin --tty -c monolith /bin/sh
Paso 12
Opcional: En la shell, puede usar el comando ping para probar la conectividad externa (orientada al exterior).
ping -c 3 google.com
Paso 13
Salga de la shell.
exit
Como puede ver, interactuar con los pods es tan sencillo como usar el comando kubectl. Si necesita probar un contenedor en forma remota o bien obtener una shell de acceso, Kubernetes le proporciona todo lo que necesita para comenzar.
Paso 14
Para salir de kubectl port-forward y kubectl logs en las terminales 2 y 3, presione Ctrl+C.
Cómo supervisar y realizar verificaciones de estado
Kubernetes admite aplicaciones de supervisión en forma de sondeos de preparación y capacidad de respuesta. Se pueden realizar verificaciones de estado en cada contenedor de un pod. Los sondeos de preparación indican cuando un pod está "listo" para procesar el tráfico. Los sondeos de capacidad de respuesta indican si un contenedor es "responsivo". Si un sondeo de capacidad de respuesta falla varias veces, el contenedor se reinicia. Los sondeos de capacidad de respuesta que continúan fallando hacen que un pod entre en un bucle de fallas. Si falla una verificación de preparación, el contenedor se marca como no listo y se quita de cualquier balanceador de cargas.
En este lab, desplegará un nuevo pod llamado healthy-monolith, que se basa en gran medida en el pod monolith con la incorporación de sondeos de preparación y capacidad de respuesta.
En este lab, aprenderá a realizar lo siguiente:
-
Crear pods con sondeos de preparación y capacidad de respuesta
-
Solucionar problemas de fallas en los sondeos de preparación y capacidad de respuesta
Cómo crear pods con sondeos de capacidad de respuesta y preparación
Paso 1
Explore el archivo de configuración del pod healthy-monolith:
cat pods/healthy-monolith.yaml
Paso 2
Cree el pod healthy-monolith con kubectl:
kubectl create -f pods/healthy-monolith.yaml
Haga clic en Revisar mi progreso para verificar el objetivo.
Paso 3
Los pods no se marcan como listo hasta que el sondeo de preparación devuelva una respuesta de HTTP 200. Use el comando kubectl describe para ver los detalles del pod healthy-monolith.
kubectl describe pod healthy-monolith
Sondeos de preparación
Vea cómo Kubernetes responde a las fallas de los sondeos de preparación. El contenedor monolith admite la capacidad de forzar fallas de sus sondeos de preparación y capacidad de respuesta. Esto le permite simular fallas para el pod healthy-monolith.
Paso 1
Use el comando kubectl port-forward en la terminal 2 para redireccionar un puerto local al puerto de estado del pod healthy-monolith:
kubectl port-forward healthy-monolith 10081:81
Paso 2
Fuerce el sondeo de preparación del contenedor monolith a que falle. Use el comando curl en la terminal 1 para alternar el estado del sondeo de preparación. Tenga en cuenta que este comando no muestra ningún resultado:
curl http://127.0.0.1:10081/readiness/status
Paso 3
Obtenga el estado del pod healthy-monolith mediante el comando kubectl get pods -w:
kubectl get pods healthy-monolith -w
Paso 4
Presione Ctrl+C cuando haya 0/1 contenedores listos. Use el comando kubectl describe para obtener más detalles sobre la falla del sondeo de preparación:
kubectl describe pods healthy-monolith
Paso 5
Observe los eventos de los detalles del informe del pod healthy-monolith sobre las fallas de los sondeos de preparación.
Para forzar al sondeo de preparación del contenedor monolith a que pase, alterne el estado del sondeo de preparación mediante el comando curl:
curl http://127.0.0.1:10081/readiness/status
Paso 6
Espere aproximadamente 15 segundos y obtenga el estado del pod healthy-monolith mediante el comando kubectl get pods:
kubectl get pods healthy-monolith
Paso 7
Presione Ctrl+C en la terminal 2 para cerrar el comando kubectl proxy (es decir, port-forward).
Sondeos de capacidad de respuesta
Sobre la base de lo que aprendió en el instructivo anterior, use los comandos kubectl port-forward y curl para forzar la falla del sondeo de capacidad de respuesta del contenedor monolith. Observe cómo Kubernetes responde a las fallas de los sondeos de capacidad de respuesta.
Paso 1
Use el comando kubectl port-forward para redireccionar un puerto local al puerto de estado del pod healthy-monolith en la terminal 2.
kubectl port-forward healthy-monolith 10081:81
Paso 2
Para forzar al sondeo de preparación del contenedor monolith a que pase, alterne el estado del sondeo de preparación mediante el uso del comando curl en otra terminal:
curl http://127.0.0.1:10081/healthz/status
Paso 3
Obtenga el estado del pod healthy-monolith mediante el comando kubectl get pods -w:
kubectl get pods healthy-monolith -w
Paso 4
Cuando falla un sondeo de capacidad de respuesta, el contenedor se reinicia. Una vez reiniciado, el pod healthy-monolith debería volver a un buen estado. Presione Ctrl+C para salir de ese comando cuando se reinicie el pod. Tome nota del número de reinicios.
Paso 5
Use el comando kubectl describe para obtener más detalles sobre las fallas del sondeo de capacidad de respuesta. Puede ver los eventos relacionados en los casos en que falló el sondeo de capacidad de respuesta y se reinició el pod.
kubectl describe pods healthy-monolith
Paso 6
Cuando haya terminado, presione Ctrl+C en la terminal 2 para cerrar el comando kubectl proxy.
Servicios
Próximos pasos:
-
Cómo crear un servicio
-
Cómo usar los selectores de etiquetas para exponer de forma externa un conjunto limitado de pods
Cómo crear un servicio
Antes de crear sus servicios, cree un pod seguro con un servidor nginx llamado secure-monolith que pueda manejar el tráfico HTTPS.
Paso 1
Cree dos volúmenes que utilizará el pod seguro para importar (o consumir) los datos.
El primer volumen de tipo secret almacena archivos del certificado TLS para su servidor nginx.
Vuelva a la terminal 1 y cree el primer volumen mediante el siguiente comando:
kubectl create secret generic tls-certs --from-file tls/
Cree el segundo volumen de tipo ConfigMap para contener el archivo de configuración de nginx:
kubectl create configmap nginx-proxy-conf --from-file nginx/proxy.conf
Paso 2
Explore el archivo proxy.conf que nginx usará.
cat nginx/proxy.conf
Este archivo especifica que SSL está ACTIVO y la ubicación de los archivos de certificación en el sistema de archivos del contenedor.
Paso 3
Explore el archivo de configuración del pod secure-monolith.
cat pods/secure-monolith.yaml
Paso 4
Ejecute el siguiente comando para crear el pod secure-monolith con sus datos de configuración:
kubectl create -f pods/secure-monolith.yaml
Ahora que tiene un pod seguro, exponga de forma externa el pod secure-monolith mediante un servicio de Kubernetes.
Paso 5
Explore el archivo de configuración del servicio monolith.
cat services/monolith.yaml
Paso 6
Use el comando kubectl create para crear el servicio monolith a partir del archivo de configuración de este servicio:
kubectl create -f services/monolith.yaml
Normalmente, Kubernetes se encarga de la asignación de puertos. En este lab, usted eligió uno para que más adelante sea más fácil configurar las verificaciones de estado.
Paso 7
Use el comando gcloud compute firewall-rules para permitir el tráfico hacia el servicio monolith en el puerto de nodo expuesto:
gcloud compute firewall-rules create allow-monolith-nodeport --allow=tcp:31000
Ahora que todo está configurado, debería poder probar el servicio secure-monolith desde fuera del clúster sin usar la redirección de puertos.
Paso 8
Obtenga una dirección IP para uno de sus nodos:
gcloud compute instances list
Paso 9
Intente abrir la URL en el navegador:
https://<EXTERNAL_IP>:31000
Cómo agregar etiquetas a los pods
De momento, el servicio 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.
Paso 1
Determine que haya varios pods en ejecución con la etiqueta monolith.
kubectl get pods -l "app=monolith"
Paso 2
Sin embargo, ¿qué sucede con app=monolith y secure=enabled?
kubectl get pods -l "app=monolith,secure=enabled"
Paso 3
Use el comando kubectl label para agregar la etiqueta faltante secure=enabled al pod secure-monolith.
kubectl label pods secure-monolith 'secure=enabled'
Haga clic en Revisar mi progreso para verificar el objetivo.
Paso 4
Verifique que las etiquetas estén actualizadas.
kubectl get pods secure-monolith --show-labels
Paso 5
Vea la lista de extremos en el servicio monolith.
kubectl get endpoints monolith
Paso 6
Pruébelo con uno de sus nodos nuevamente.
gcloud compute instances list | grep gke-
Abra la siguiente URL en su navegador. Deberá hacer clic en la advertencia de SSL porque secure-monolith usa un certificado autofirmado:
https://<EXTERNAL_IP>:31000
Finalice su lab
Cuando haya completado el lab, haga clic en Finalizar lab. Google Cloud Skills Boost quitará los recursos que usó y limpiará la cuenta.
Tendrá la oportunidad de calificar su experiencia en el lab. Seleccione la cantidad de estrellas que corresponda, ingrese un comentario y haga clic en Enviar.
La cantidad de estrellas indica lo siguiente:
- 1 estrella = Muy insatisfecho
- 2 estrellas = Insatisfecho
- 3 estrellas = Neutral
- 4 estrellas = Satisfecho
- 5 estrellas = Muy satisfecho
Puede cerrar el cuadro de diálogo si no desea proporcionar comentarios.
Para enviar comentarios, sugerencias o correcciones, use la pestaña Asistencia.
Copyright 2020 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.
