Entorno de desarrollo

1. Descripción general

En este lab, se demuestran las funciones y capacidades diseñadas para optimizar el flujo de trabajo de desarrollo de los ingenieros de software encargados de desarrollar aplicaciones de Python en un entorno alojado en contenedores. El desarrollo de contenedores típico requiere que el usuario comprenda los detalles de los contenedores y el proceso de compilación de contenedores. Además, los desarrolladores suelen tener que interrumpir su flujo de trabajo y salir del IDE para probar y depurar sus aplicaciones en entornos remotos. Con las herramientas y tecnologías que se mencionan en este instructivo, los desarrolladores pueden trabajar de manera eficaz con aplicaciones en contenedores sin salir de su IDE.

¿Qué es Cloud Workstations?

Cloud Workstations proporciona entornos de desarrollo administrados en Google Cloud con seguridad integrada y entornos de desarrollo previamente configurados, pero personalizables. Accede a Cloud Workstations a través de un IDE basado en navegador, desde varios editores de código locales (como VS Code o IDE de JetBrains, como IntelliJ IDEA Ultimate y PyCharm Professional) o a través de SSH.

Cloud Workstations usa los siguientes recursos:

• Los administradores crean clústeres de estaciones de trabajo
• En cada clúster de estaciones de trabajo, los administradores crean uno o más parámetros de configuración de estaciones de trabajo que actúan como plantillas para las estaciones de trabajo.
• Los desarrolladores pueden crear estaciones de trabajo que definan entornos de desarrollo que proporcionen un IDE de Cloud, herramientas de lenguaje, bibliotecas y mucho más.

Cloud Workstations permite que los administradores de TI y de seguridad aprovisionen, escalen, administren y protejan fácilmente sus entornos de desarrollo, y que los desarrolladores accedan a entornos de desarrollo con configuraciones coherentes y herramientas personalizables.

Cloud Workstations ayuda a cambiar el enfoque de seguridad mejorando la postura de seguridad de tus entornos de desarrollo de aplicaciones. Tiene funciones de seguridad, como los Controles del servicio de VPC, entrada o salida privadas, actualización obligatoria de imágenes y políticas de acceso de Identity and Access Management.

¿Qué es Cloud Code?

Cloud Code proporciona compatibilidad con IDE durante todo el ciclo de desarrollo de las aplicaciones de Kubernetes y Cloud Run, desde la creación y personalización de una aplicación nueva de plantillas de muestra hasta la ejecución de tu aplicación terminada. Cloud Code te asiste durante el proceso con muestras listas para ejecutar, fragmentos de configuración listos para usar y una experiencia de depuración a tu medida. Todas estas funciones facilitan la implementación en Kubernetes y Cloud Run en gran medida.

Estas son algunas de las funciones de Cloud Code:

• Compila y ejecuta aplicaciones de forma continua
• Asistencia con la depuración de aplicaciones de Kubernetes en desarrollo
• Transmisión y visualización de registros

Obtén más información sobre otras funciones de Cloud Code.

Qué aprenderás

En este lab, aprenderás métodos para desarrollar con contenedores en GCP, incluidos los siguientes:

• Revisa Cloud Workstations
• Iniciar estación de trabajo
• Revisa Cloud Code
• Depura en Kubernetes

2. Configuración y requisitos

Cómo configurar el entorno a tu propio ritmo

1. Accede a Google Cloud Console y crea un proyecto nuevo o reutiliza uno existente. Si aún no tienes una cuenta de Gmail o de Google Workspace, debes crear una.

• El Nombre del proyecto es el nombre visible de los participantes de este proyecto. Es una cadena de caracteres que no se utiliza en las APIs de Google. Puedes actualizarla en cualquier momento.
• El ID del proyecto es único en todos los proyectos de Google Cloud y es inmutable (no se puede cambiar después de configurarlo). La consola de Cloud genera automáticamente una cadena única. Por lo general, no importa cuál sea. En la mayoría de los codelabs, deberás hacer referencia al ID del proyecto (suele identificarse como PROJECT_ID). Si no te gusta el ID que se generó, podrías generar otro aleatorio. También puedes probar uno propio y ver si está disponible. No se puede cambiar después de este paso y se usará el mismo durante todo el proyecto.
• Recuerda que hay un tercer valor, un número de proyecto, que usan algunas APIs. Obtén más información sobre estos tres valores en la documentación.

Precaución: El ID del proyecto es único a nivel global y no lo puede usar nadie más después de que lo hayas seleccionado. Eres el único usuario de ese ID. Incluso si se borra un proyecto, no se puede volver a usar el ID.

Nota: Si usas una cuenta de Gmail, puedes configurar la ubicación predeterminada como Sin organización. Si usas una cuenta de Google Workspace, elige una ubicación adecuada para tu organización.

2. A continuación, deberás habilitar la facturación en la consola de Cloud para usar las APIs o los recursos de Cloud. Ejecutar este codelab no debería costar mucho, tal vez nada. Para cerrar recursos y evitar que se generen cobros más allá de este instructivo, puedes borrar los recursos que creaste o borrar todo el proyecto. Los usuarios nuevos de Google Cloud son aptos para participar en el programa Prueba gratuita de USD 300.

Configuración del entorno

En Cloud Shell, configura el ID y el número de tu proyecto. Guárdalos como variables PROJECT_ID y PROJECT_ID.

export PROJECT_ID=$(gcloud config get-value project)
export PROJECT_NUMBER=$(gcloud projects describe $PROJECT_ID \
    --format='value(projectNumber)')

En este lab, implementarás código en GKE. También usarás Cloud Workstations como IDE.

La siguiente secuencia de comandos de configuración prepara esta infraestructura por ti.

1. Descarga la secuencia de comandos de configuración y haz que sea ejecutable.

wget https://raw.githubusercontent.com/GoogleCloudPlatform/container-developer-workshop/main/labs/python/setup_with_cw.sh
chmod +x setup_with_cw.sh

2. Abre el archivo setup_with_cw.sh y edita los valores de las contraseñas que actualmente están configuradas como CHANGEME.
3. Ejecuta la secuencia de comandos de configuración para crear un clúster de GKE que usarás en este lab. Esta configuración tardará alrededor de 20 minutos.

./setup_with_cw.sh &

4. Abre Cloud Workstations en Cloud Console. Espera a que el clúster tenga el estado READY antes de continuar con los siguientes pasos.
5. Si se desconectó tu sesión de Cloud Shell, haz clic en "Reconnect" y, luego, ejecuta el comando de la CLI de gcloud para establecer el ID del proyecto. Antes de ejecutar el comando, reemplaza el ID del proyecto de ejemplo que se muestra a continuación por el ID de tu proyecto de Qwiklabs.

gcloud config set project qwiklabs-gcp-project-id

6. Descarga y ejecuta la siguiente secuencia de comandos en la terminal para crear la configuración de Cloud Workstations.

wget https://raw.githubusercontent.com/GoogleCloudPlatform/container-developer-workshop/main/labs/python/workstation_config_setup.sh
chmod +x workstation_config_setup.sh
./workstation_config_setup.sh

Clúster y configuración de Cloud Workstations

Abre Cloud Workstations en Cloud Console. Verifica que el clúster tenga el estado READY.

Verifica el estado de las configuraciones existentes.

Crea una estación de trabajo nueva.

Cambia el nombre a my-workstation y selecciona la configuración existente: codeoss-python.

Iniciar estación de trabajo

1. Inicia la estación de trabajo. La estación de trabajo tardará unos minutos en iniciarse.

2. Para permitir las cookies de terceros, haz clic en el ícono de la barra de direcciones.

3. Haz clic en “¿No funciona el sitio?”.

4. Haz clic en "Permitir cookies".

5. Una vez que se inicie la estación de trabajo, aparecerá el IDE de Code OSS.

Haz clic en "Marcar como completado" en la página de introducción del IDE de la estación de trabajo.

3. Descripción general de Cloud Code

Revisar las diferentes secciones disponibles en Cloud Code

• Desarrollo de Kubernetes. Obtén un entorno de desarrollo y depuración de Kubernetes integrado por completo en tu IDE. Crea y administra clústeres directamente desde el IDE.
• Depura aplicaciones en ejecución. Depura el código en tus IDE con Cloud Code para VS Code y Cloud Code para IntelliJ aprovechando las funciones de depuración de IDE integradas.
• Explora las implementaciones. Observa los metadatos y recursos subyacentes para los clústeres de Kubernetes y los servicios de Cloud Run. Puedes recuperar una descripción, ver registros, administrar secretos o pasar una terminal directamente dentro de un Pod.
• Simplifica el desarrollo local de Kubernetes. Cloud Code para IDE usa herramientas populares como Skaffold, Jib y Kubectl a fin de ofrecerte comentarios continuos sobre tu código en tiempo real.

Accede a Google Cloud

1. Haz clic en el ícono de Cloud Code y selecciona "Acceder a Google Cloud":

2. Haz clic en "Continuar al acceso".

3. Verifica el resultado en la terminal y abre el vínculo:

4. Accede con las credenciales de estudiante de Qwiklabs.

5. Selecciona "Permitir":

6. Copia el código de verificación y regresa a la pestaña Workstation.

7. Pega el código de verificación y presiona Intro.

Haz clic en el botón "Permitir" si ves este mensaje para que puedas copiar y pegar en la estación de trabajo.

4. Crea una nueva aplicación inicial de Python

En esta sección, crearás una nueva aplicación de Python.

1. Abre una terminal nueva.

2. Crea un directorio nuevo y ábrelo como espacio de trabajo

mkdir music-service && cd music-service

code-oss-cloud-workstations -r --folder-uri="$PWD"

3. Crea un archivo llamado requirements.txt y copia el siguiente contenido en él.

Flask
gunicorn
ptvsd==4.3.2

4. Crea un archivo llamado app.py y pega el siguiente código en él:

import os
from flask import Flask, request, jsonify

app = Flask(__name__)

@app.route("/")
def hello_world():
    message="Hello, World!"
    return message

if __name__ == '__main__':
    server_port = os.environ.get('PORT', '8080')
    app.run(debug=False, port=server_port, host='0.0.0.0')

5. Crea un archivo llamado Dockerfile y pega el siguiente código en él:

FROM python:3.8
ARG FLASK_DEBUG=0
ENV FLASK_DEBUG=$FLASK_DEBUG
ENV FLASK_APP=app.py
WORKDIR /app
COPY requirements.txt .
RUN pip install --trusted-host pypi.python.org -r requirements.txt
COPY . .
ENTRYPOINT ["python3", "-m", "flask", "run", "--port=8080", "--host=0.0.0.0"]

Nota: FLASK_DEBUG=1 te permite volver a cargar automáticamente los cambios de código en una app de Flask en Python. Este Dockerfile te permite pasar este valor como un argumento de compilación.

Generar manifiestos

En tu terminal, ejecuta el siguiente comando para generar un skaffold.yaml y un deployment.yaml predeterminados.

1. Inicializa Skaffold con el siguiente comando:

skaffold init --generate-manifests

Cuando se te solicite, usa las flechas para mover el cursor y la barra espaciadora para seleccionar las opciones.

Elige:

• 8080 para el puerto
• y para guardar la configuración

Actualiza la configuración de Skaffold

• Cambia el nombre de la aplicación predeterminada
• Abrir skaffold.yaml
• Selecciona el nombre de la imagen que está configurado actualmente como dockerfile-image.
• Haz clic con el botón derecho y elige Cambiar todas las ocurrencias.
• Escribe el nombre nuevo como python-app
• Edita aún más la sección de compilación para que quede de la siguiente manera:
• Agrega docker.buildArgs al pase FLASK_DEBUG=1.
• Sincroniza la configuración para cargar los cambios en los archivos *.py del IDE al contenedor en ejecución

Después de las ediciones, la sección de compilación del archivo skaffold.yaml se vería de la siguiente manera:

build:
 artifacts:
 - image: python-app
   docker:
     buildArgs:
       FLASK_DEBUG: "1"
     dockerfile: Dockerfile
   sync:
     infer:
     - '**/*.py'

Modifica el archivo de configuración de Kubernetes

1. Cómo cambiar el nombre predeterminado

• Abre el archivo deployment.yaml.
• Selecciona el nombre de la imagen que está configurado actualmente como dockerfile-image.
• Haz clic con el botón derecho y elige Cambiar todas las ocurrencias.
• Escribe el nombre nuevo como python-app

5. Explicación del proceso de desarrollo

Con la lógica empresarial agregada, ahora puedes implementar y probar tu aplicación. En la siguiente sección, se mostrará el uso del complemento de Cloud Code. Entre otras cosas, este complemento se integra con Skaffold para optimizar tu proceso de desarrollo. Cuando realices la implementación en GKE en los siguientes pasos, Cloud Code y Skaffold compilarán automáticamente tu imagen de contenedor, la enviarán a Container Registry y, luego, implementarán la aplicación your en GKE. Esto sucede en segundo plano, abstrayendo los detalles del flujo del desarrollador.

Agrega un clúster de Kubernetes

1. Agrega un clúster

2. Selecciona Google Kubernetes Engine:

3. Selecciona el proyecto.

4. Selecciona "python-cluster", que se creó en la configuración inicial.

5. El clúster ahora aparece en la lista de clústeres de Kubernetes en Cloud Code. Desde aquí, puedes navegar y explorar el clúster.

Implementar en Kubernetes

1. En el panel que se encuentra en la parte inferior del editor de Cloud Shell, selecciona Cloud Code. 

2. En el panel que aparece en la parte superior, selecciona Run on Kubernetes.

Si se te solicita, selecciona Sí para usar el contexto actual de Kubernetes.

Este comando inicia una compilación del código fuente y, luego, ejecuta las pruebas. La compilación y las pruebas tardarán unos minutos en ejecutarse. Estas pruebas incluyen pruebas de unidades y un paso de validación que verifica las reglas establecidas para el entorno de implementación. Este paso de validación ya está configurado y garantiza que recibas advertencias sobre problemas de implementación, incluso mientras sigues trabajando en tu entorno de desarrollo.

3. La primera vez que ejecutes el comando, aparecerá un mensaje en la parte superior de la pantalla que te preguntará si deseas el contexto actual de Kubernetes. Selecciona "Sí" para aceptar y usar el contexto actual.
4. A continuación, se mostrará un mensaje en el que se preguntará qué registro de contenedores usar. Presiona Intro para aceptar el valor predeterminado proporcionado.
5. Selecciona la pestaña "Salida" en el panel inferior para ver el progreso y las notificaciones. En el menú desplegable, selecciona “Kubernetes: Run/Debug”.

6. Selecciona "Kubernetes: Run/Debug - Detailed" en el menú desplegable del canal a la derecha para ver detalles adicionales y registros que se transmiten en vivo desde los contenedores.

Cuando finalicen la compilación y las pruebas, los registros de la pestaña Resultado incluirán la URL http://localhost:8080 en la vista "Kubernetes: Run/Debug".

7. En la terminal de Cloud Code, coloca el cursor sobre la primera URL en el resultado (http://localhost:8080) y, luego, en la información sobre herramientas que aparece, selecciona Abrir en la vista previa web.
8. Se abrirá una nueva pestaña del navegador y se mostrará el mensaje: Hello, World!

Recarga en caliente

1. Abre el archivo app.py.
2. Cambia el mensaje de saludo a Hello from Python.

Observa de inmediato que, en la ventana Output, vista Kubernetes: Run/Debug, el observador sincroniza los archivos actualizados con el contenedor en Kubernetes.

Update initiated
Build started for artifact python-app
Build completed for artifact python-app

Deploy started
Deploy completed

Status check started
Resource pod/python-app-6f646ffcbb-tn7qd status updated to In Progress
Resource deployment/python-app status updated to In Progress
Resource deployment/python-app status completed successfully
Status check succeeded
...

3. Si cambias a la vista Kubernetes: Run/Debug - Detailed, notarás que reconoce los cambios en el archivo, luego compila y vuelve a implementar la app.

files modified: [app.py]
Syncing 1 files for gcr.io/veer-pylab-01/python-app:3c04f58-dirty@sha256:a42ca7250851c2f2570ff05209f108c5491d13d2b453bb9608c7b4af511109bd
Copying files:map[app.py:[/app/app.py]]togcr.io/veer-pylab-01/python-app:3c04f58-dirty@sha256:a42ca7250851c2f2570ff05209f108c5491d13d2b453bb9608c7b4af511109bd
Watching for changes...
[python-app] * Detected change in '/app/app.py', reloading
[python-app] * Restarting with stat
[python-app] * Debugger is active!
[python-app] * Debugger PIN: 744-729-662

4. Actualiza la pestaña del navegador en la que viste los resultados anteriores para ver los resultados actualizados.

Depuración

1. Ve a la vista de depuración y detén el subproceso actual . Si te lo pregunta, puedes elegir limpiar después de cada ejecución.
2. 
3. Haz clic en Cloud Code en el menú inferior y selecciona Debug on Kubernetes para ejecutar la aplicación en modo debug.

• En la vista Kubernetes Run/Debug - Detailed de la ventana Output, observa que Skaffold implementará esta aplicación en modo de depuración.

4. La primera vez que se ejecute, aparecerá un mensaje que preguntará dónde se encuentra la fuente dentro del contenedor. Este valor se relaciona con los directorios del Dockerfile.

Presiona Intro para aceptar el valor predeterminado.

La compilación y la implementación de la aplicación tardarán un par de minutos. Si se desconecta la sesión de depuración, vuelve a ejecutar los pasos para "Depurar en Kubernetes" de la sección "Sesiones de desarrollo".

5. Cuando se completa el proceso Verás un depurador adjunto y la pestaña Output dirá: Attached debugger to container "python-app-8476f4bbc-h6dsl" successfully., y se mostrará la URL http://localhost:8080.

Port forwarding pod/python-app-8bd64cf8b-cskfl in namespace default, remote port 5678 -> http://127.0.0.1:5678

6. La barra de estado inferior cambia su color de azul a naranja, lo que indica que está en modo de depuración.

7. En la vista Kubernetes Run/Debug, observa que se inició un contenedor depurable.

**************URLs*****************
Forwarded URL from service python-app: http://localhost:8080
Debuggable container started pod/python-app-8bd64cf8b-cskfl:python-app (default)
Update succeeded
***********************************

Utiliza puntos de interrupción

1. Abre el archivo app.py.
2. Ubica la instrucción que dice return message.
3. Para agregar un punto de interrupción a esa línea, haz clic en el espacio en blanco a la izquierda del número de línea. Aparecerá un indicador rojo para señalar que se estableció el punto de interrupción.
4. Vuelve a cargar el navegador y observa que el depurador detiene el proceso en el punto de interrupción y te permite investigar las variables y el estado de la aplicación que se ejecuta de forma remota en GKE.
5. Haz clic en la sección VARIABLES.
6. Haz clic en Locales y allí encontrarás la variable "message".
7. Haz doble clic en el nombre de la variable "message" y, en la ventana emergente, cambia el valor por algo diferente, como "Greetings from Python".
8. Haz clic en el botón Continuar en el panel de control de depuración.
9. Revisa la respuesta en tu navegador, que ahora muestra el valor actualizado que acabas de ingresar.
10. Para detener el modo "Depuración", presiona el botón de detener y quita el punto de interrupción haciendo clic en él de nuevo.

6. Limpieza

¡Felicitaciones! En este lab, creaste una nueva aplicación de Python desde cero y la configuraste para que funcione de manera eficaz con contenedores. Luego, implementaste y depuraste tu aplicación en un clúster de GKE remoto siguiendo el mismo flujo de desarrollador que se encuentra en las pilas de aplicaciones tradicionales.

Para limpiar después de completar el lab, haz lo siguiente:

1. Borra los archivos que se usaron en el lab

cd ~ && rm -rf ~/music-service

2. Borra el proyecto para quitar toda la infraestructura y los recursos relacionados

—

Última actualización: 22/3/23