Ruta de aprendizaje: transformar un monolito en una aplicación de GKE - Contenerizar la aplicación modular

Este es el cuarto tutorial de un recorrido de aprendizaje que te enseña a modularizar y contenerizar una aplicación monolítica.

El recorrido de aprendizaje consta de los siguientes tutoriales:

  1. Descripción general
  2. Información sobre el monolito
  3. Modularizar el monolito
  4. Preparar la aplicación modular para la contenerización
  5. Contenerizar la aplicación modular (este tutorial)
  6. Desplegar la aplicación en un clúster de GKE

En el tutorial anterior, Prepara la aplicación modular para la contenedorización, viste los cambios que debían hacerse en la versión modular de la aplicación Cymbal Books para prepararla para la contenedorización. En este tutorial, vas a crear un contenedor para la aplicación.

Costes

Puedes completar este tutorial sin incurrir en ningún cargo. Sin embargo, si sigues los pasos del siguiente tutorial de esta serie, se te cobrará en tu cuenta deGoogle Cloud . Los costes empiezan cuando habilitas GKE y despliegas la aplicación Cymbal Books en un clúster de GKE. Estos costes incluyen los cargos por clúster de GKE, tal como se indica en la página de precios, y los cargos por ejecutar máquinas virtuales de Compute Engine.

Para evitar cargos innecesarios, inhabilita GKE o elimina el proyecto una vez que hayas completado este tutorial.

Antes de empezar

Antes de empezar este tutorial, asegúrate de haber completado los tutoriales anteriores de la serie. Para ver un resumen de toda la serie y enlaces a tutoriales concretos, consulta el plan de formación Transformar una aplicación monolítica en una aplicación de GKE: resumen.

Configurar un entorno

En esta sección, configurarás un entorno en el que se contenga la aplicación modular. En concreto, seguirás estos pasos:

  1. Selecciona o crea un Google Cloud proyecto.
  2. Habilita las APIs necesarias
  3. Conectar Cloud Shell a tu Google Cloud proyecto
  4. Definir las variables de entorno predeterminadas
  5. Crear un repositorio en Artifact Registry
  6. Configurar Docker para Artifact Registry
  7. Obtener el código del tutorial

Selecciona o crea un Google Cloud proyecto

  1. In the Google Cloud console, on the project selector page, select or create a Google Cloud project.

    Roles required to select or create a project

    • Select a project: Selecting a project doesn't require a specific IAM role—you can select any project that you've been granted a role on.
    • Create a project: To create a project, you need the Project Creator (roles/resourcemanager.projectCreator), which contains the resourcemanager.projects.create permission. Learn how to grant roles.

    Go to project selector

  2. Verify that billing is enabled for your Google Cloud project.

Habilita las APIs necesarias

Para trabajar con imágenes de contenedor y Kubernetes en tu Google Cloud proyecto, debes habilitar las siguientes APIs:

  • API de Artifact Registry: esta API habilita Artifact Registry, que es un servicio para almacenar y gestionar tus imágenes de contenedor.
  • API Kubernetes Engine: esta API proporciona acceso a GKE.

Para habilitar estas APIs, visita la página para habilitar las APIs en la consola de Google Cloud .

Conectar Cloud Shell a tu proyecto de Google Cloud

Ahora que has configurado tu Google Cloud proyecto, debes iniciar una instancia de Cloud Shell y conectarla a tu Google Cloudproyecto. Cloud Shell es una herramienta de línea de comandos que te permite crear y gestionar los recursos de un proyecto directamente desde el navegador. Cloud Shell tiene preinstaladas dos herramientas importantes: gcloud CLI y kubectl CLI. En este tutorial, usarás la CLI de gcloud para interactuar con Google Cloud y, en el siguiente, usarás la CLI de kubectl para gestionar la aplicación Cymbal Books que se ejecuta en GKE.

Para conectar una instancia de Cloud Shell con tu Google Cloud proyecto, sigue estos pasos:

  1. Ve a la Google Cloud consola:

    Google Cloud console

  2. En la consola, haz clic en el botón Activar Cloud Shell: Activar Cloud Shell

    Se abrirá una sesión de Cloud Shell en un marco de la parte inferior de la consola.

  3. Define tu proyecto predeterminado en la CLI de Google Cloud con el siguiente comando:

    gcloud config set project PROJECT_ID

    Sustituye PROJECT_ID por el ID del proyecto que has creado o seleccionado en la sección anterior, Seleccionar o crear proyecto Google Cloud . Un ID de proyecto es una cadena única que diferencia tu proyecto de todos los demás proyectos de Google Cloud. Para encontrar el ID del proyecto, ve al selector de proyectos. En esa página, puede ver los IDs de cada uno de sus Google Cloud proyectos.

Definir las variables de entorno predeterminadas

Para simplificar los comandos que ejecutes a lo largo de este tutorial, ahora vas a definir algunas variables de entorno en Cloud Shell. Estas variables almacenan valores como el ID de tu proyecto, la región del repositorio y la etiqueta de la imagen. Una vez que hayas definido estas variables, podrás reutilizarlas en varios comandos haciendo referencia al nombre de la variable (por ejemplo, $REPOSITORY_NAME) en lugar de volver a escribir o sustituir los valores cada vez. De esta forma, el tutorial es más fácil de seguir y se reduce el riesgo de errores.

Para configurar tu entorno con Cloud Shell, sigue estos pasos:

export PROJECT_ID=$(gcloud config get project)
export REPOSITORY_REGION=REPOSITORY_REGION
export REPOSITORY_NAME=REPOSITORY_NAME
export REPOSITORY_DESCRIPTION="REPOSITORY_DESCRIPTION"
export TAG=TAG

Haz los cambios siguientes:

  • REPOSITORY_REGION: la región en la que quiere que se aloje su repositorio de Artifact Registry. Por ejemplo, us-central1 (Iowa), us-west1 (Oregón) o europe-west1 (Bélgica). Para ver una lista completa de las regiones, consulta Regiones y zonas.
  • REPOSITORY_NAME: el nombre de tu repositorio. Por ejemplo, book-review-service-repo.
  • REPOSITORY_DESCRIPTION: una breve descripción del propósito del repositorio. Por ejemplo, "Repository for storing Docker images for the book review service".
  • TAG: la etiqueta que quieres aplicar a una imagen. Una etiqueta es un identificador que puedes asociar a una versión específica de una imagen de contenedor. Puedes usar convenciones de nomenclatura de etiquetas como estas para indicar claramente las diferentes versiones de una imagen:
    • v1
    • v1.2.3
    • Una etiqueta descriptiva, como feature-x-dev
    • Una etiqueta que indica el entorno, como test

Crear un repositorio en Artifact Registry

A continuación, crea un repositorio en Artifact Registry. Un repositorio es una ubicación de almacenamiento donde se guardan las imágenes de contenedor. Cuando creas una imagen de contenedor, necesitas un lugar donde almacenarla para que se pueda implementar más adelante en un clúster de Kubernetes. Artifact Registry te permite crear y gestionar estos repositorios en tu Google Cloud proyecto.

Para crear un repositorio en Artifact Registry, ejecuta el siguiente comando:

gcloud artifacts repositories create ${REPOSITORY_NAME} \
    --repository-format=docker \
    --location=${REPOSITORY_REGION} \
    --description="${REPOSITORY_DESCRIPTION}"

Si el comando se ejecuta correctamente, el resultado será similar al siguiente:

Waiting for operation [...] to complete...done.
Created repository [book-review-service-repo].

Configurar Docker para Artifact Registry

A continuación, configura Docker para que pueda comunicarse de forma segura con Artifact Registry deGoogle Cloud. Docker es una herramienta que puedes usar para empaquetar y ejecutar software de forma coherente en diferentes entornos. En la siguiente sección, encontrarás más información sobre cómo funciona Docker. Por ahora, debes configurarlo para que pueda conectarse a Artifact Registry.

Si no configuras Docker de esta forma, no podrás enviar las imágenes de contenedor a Artifact Registry (una tarea que realizarás más adelante en este tutorial). Tampoco puedes extraer las imágenes de contenedor de Artifact Registry y desplegarlas en un clúster de GKE (una tarea que realizarás en el siguiente tutorial).

Para configurar Docker de forma que se autentique con Artifact Registry, ejecuta este comando:

gcloud auth configure-docker ${REPOSITORY_REGION}-docker.pkg.dev

Obtener el código del tutorial

Ahora que has configurado tu entorno de Cloud Shell, debes descargar el código del tutorial en Cloud Shell. Aunque ya hayas clonado el repositorio en tu máquina local, debes volver a clonarlo en tu instancia de Cloud Shell.

Aunque puedes completar este tutorial en tu máquina local, tendrías que instalar y configurar manualmente varias herramientas, como Docker, kubectl y gcloud CLI. Es más fácil usar Cloud Shell porque ya viene preconfigurado con todas estas herramientas.

En tu instancia de Cloud Shell, ejecuta el siguiente comando para clonar el repositorio de GitHub:

git clone https://github.com/GoogleCloudPlatform/kubernetes-engine-samples.git

Conceptos básicos de la contenedorización: imágenes de contenedor, contenedores y Dockerfiles

Ahora que has configurado tu entorno y has descargado el código contenedorizado, puedes contenedorizar la aplicación. Para ello, debes usar un Dockerfile para empaquetar cada módulo de Cymbal Books (página principal, detalles del libro, imágenes y reseñas de libros) en una imagen de contenedor. Cuando la aplicación se despliega en el clúster de GKE, Kubernetes usa estas imágenes de contenedor para crear contenedores en ejecución en el clúster.

En las siguientes secciones se explican estos conceptos en detalle.

¿Qué es la creación en contenedores?

La creación en contenedores empaqueta un módulo y todas sus dependencias, como bibliotecas y archivos de configuración, en una unidad llamada imagen de contenedor. Los desarrolladores usan esta imagen de contenedor para crear y ejecutar contenedores en cualquier entorno, desde el portátil de un desarrollador hasta un servidor de pruebas o un clúster de Kubernetes de producción.

¿Qué son las imágenes de contenedor?

Una imagen de contenedor contiene todos los archivos necesarios para ejecutar una aplicación. Estos archivos incluyen el código de la aplicación, las bibliotecas del sistema, el entorno de ejecución (por ejemplo, el intérprete de Python), los datos estáticos y cualquier otra dependencia.

En este tutorial, creará una imagen de contenedor para cada módulo de la aplicación de reseñas de libros.

¿Qué es un contenedor?

Un contenedor es un entorno aislado en el que se ejecuta el código de una imagen de contenedor. Puedes crear contenedores de dos formas: usando el comando docker run para hacer pruebas durante el desarrollo o desplegando imágenes de contenedor en un clúster de Kubernetes.

En la versión en contenedores de la aplicación Cymbal Books, cada módulo de la aplicación modular se ejecuta en su propio contenedor:

  • El contenedor de la página principal ejecuta el módulo de la página principal y gestiona las solicitudes a /.
  • El contenedor de detalles del libro ejecuta el módulo de detalles del libro y proporciona datos para endpoints como /book/1 o /book/3.
  • El contenedor de reseñas de libros ejecuta el módulo de reseñas de libros y gestiona las solicitudes a endpoints como /book/2/reviews.
  • El contenedor de imágenes ejecuta el módulo de imágenes y sirve imágenes de portada de libros para endpoints como /images/fungi_frontier.jpg.

Una de las principales ventajas de los contenedores es que Kubernetes puede crear más automáticamente cuando sea necesario. Por ejemplo, si muchos usuarios están leyendo reseñas de libros, Kubernetes puede iniciar contenedores de reseñas de libros adicionales para gestionar la carga.

Para implementar el escalado en una aplicación modular que no usa contenedores, tendrías que escribir código personalizado para iniciar nuevas instancias de un módulo y distribuir el tráfico entre ellas. Con Kubernetes, esta función de escalado está integrada, por lo que no tienes que escribir ningún código de escalado personalizado.

¿Qué son los Dockerfiles?

Un Dockerfile es una secuencia de comandos que define cómo empaquetar un módulo en una imagen de contenedor. En este tutorial, no tienes que crear ningún Dockerfile, ya que se te proporcionan en el repositorio de GitHub que clonaste anteriormente. El directorio de cada módulo de tu copia local de kubernetes-engine-samples/quickstarts/monolith-to-microservices/containerized/ contiene su propio Dockerfile.

Por ejemplo, puedes encontrar el Dockerfile del módulo home_app en tu instancia de Cloud Shell en kubernetes-engine-samples/quickstarts/monolith-to-microservices/containerized/home_app/Dockerfile. Este Dockerfile tiene el siguiente aspecto:

# Dockerfile for home_app
FROM python:3.9-slim #line 1
WORKDIR /app #line 2
COPY requirements.txt . #line 3
RUN pip install --no-cache-dir -r requirements.txt #line 4
COPY home_app.py . #line 5
COPY templates/ ./templates/ #line 6
COPY static/ ./static/ #line 7
CMD ["python", "home_app.py"] #line 8

Este Dockerfile realiza los siguientes pasos para crear la imagen de contenedor del módulo home_app:

  • Línea 1: FROM python:3.9-slim descarga un intérprete de Python 3.9 y sus archivos necesarios en la imagen del contenedor. Estos archivos permiten que se ejecute el módulo.
  • Línea 2: WORKDIR /app crea un directorio llamado /app dentro del contenedor y lo define como el directorio de trabajo actual. Todos los comandos que se ejecuten dentro del contenedor se ejecutarán desde este directorio.
  • Líneas 3 y 4: COPY requirements.txt . copia el archivo requirements.txt de tu máquina local en el directorio /app de la imagen del contenedor. El archivo requirements.txt incluye todas las bibliotecas de Python que home_app.py necesita. La línea RUN pip install instala esas bibliotecas en la imagen del contenedor.
  • Líneas 5 a 7: los comandos COPY que aparecen en estas líneas copian el código del módulo (home_app.py) y sus archivos de asistencia (plantillas y recursos estáticos) en el directorio /app de la imagen del contenedor.
  • Línea 8: CMD especifica el comando predeterminado que ejecuta Docker cuando se inicia el contenedor. En este Dockerfile, CMD ["python", "home_app.py"] indica a Docker que use el intérprete de Python para ejecutar el módulo home_app.py automáticamente cuando se inicie el contenedor.

Cómo puede la contenerización reforzar el aislamiento de datos

Las líneas de la 5 a la 7 del archivo Dockerfile, que se describieron en la sección anterior, muestran cómo la contenedorización puede aplicar un aislamiento de datos más estricto que la versión modularizada de la aplicación. En un tutorial anterior, en la sección Dar a cada módulo acceso solo a los datos que necesita, aprendiste que la versión modular de la aplicación organizaba los datos en directorios independientes, pero los módulos seguían compartiendo el mismo sistema de archivos y podían acceder a los datos de los demás.

En la versión en contenedores de la aplicación, el contenedor de cada módulo incluye solo los archivos necesarios. Por ejemplo, si el módulo home_app no necesita acceder a los datos de las reseñas de libros, esos datos no estarán en el contenedor home_app. De forma predeterminada, un contenedor no puede acceder a los archivos de otro contenedor a menos que se configure explícitamente para ello. Esto ayuda a garantizar que cada módulo esté completamente aislado y también a evitar el acceso accidental o no autorizado a los datos.

En la siguiente sección, verá cómo el comando docker build toma un Dockerfile como entrada y sigue las instrucciones del Dockerfile para crear una imagen de contenedor.

Crear imágenes de contenedor con Docker

En esta sección, crearás imágenes de contenedor Docker para cada uno de los módulos de reseñas de libros y las enviarás a tu repositorio de Artifact Registry. Usarás estas imágenes de contenedor en un tutorial posterior para desplegar y ejecutar la aplicación de ejemplo Cymbal Books en Kubernetes.

  1. Ve al directorio raíz de la aplicación en contenedor:

    cd kubernetes-engine-samples/quickstarts/monolith-to-microservices/containerized/

  2. Crea las imágenes de contenedor con el comando docker build:

    docker build -t ${REPOSITORY_REGION}-docker.pkg.dev/${PROJECT_ID}/${REPOSITORY_NAME}/home-app:${TAG} ./home_app
docker build -t ${REPOSITORY_REGION}-docker.pkg.dev/${PROJECT_ID}/${REPOSITORY_NAME}/book-details-app:${TAG} ./book_details_app
docker build -t ${REPOSITORY_REGION}-docker.pkg.dev/${PROJECT_ID}/${REPOSITORY_NAME}/book-reviews-app:${TAG} ./book_reviews_app
docker build -t ${REPOSITORY_REGION}-docker.pkg.dev/${PROJECT_ID}/${REPOSITORY_NAME}/images-app:${TAG} ./images_app

  3. Consulta las imágenes de contenedor que se han creado en tu instancia de Cloud Shell:

    docker images

    Comprueba que las siguientes imágenes aparezcan en la lista:

    • home-app
    • book-details-app
    • book-reviews-app
    • images-app

    Si aparecen las cuatro imágenes, significa que has creado correctamente el contenedor de imágenes.

Probar contenedores en Cloud Shell

Para verificar que las imágenes de contenedor se han compilado correctamente, puedes ejecutarlas como contenedores y probar sus endpoints en Cloud Shell.

Los contenedores book_details_app, book_reviews_app y images_app se pueden probar individualmente porque no necesitan comunicarse entre sí. Sin embargo, probar el contenedor home_app con Docker es difícil porque home_app está configurado para encontrar los otros contenedores que usan nombres de servicio, como http://book-details-service:8081.

Aunque es posible probar el contenedor home_app buscando la dirección IP de cada contenedor y configurando home_app para que las use en lugar de los nombres de servicio, este método requiere mucho esfuerzo. En su lugar, te recomendamos que aplaces las pruebas del contenedor home_app hasta después de desplegar la aplicación en un clúster de Kubernetes. Una vez que la aplicación esté en el clúster, puedes determinar si el módulo de casa funciona correctamente.

Sigue estos pasos para probar los contenedores:

  1. Inicia los contenedores book_details_app, book_reviews_app y images_app:

    docker run -d -p 8081:8080 ${REPOSITORY_REGION}-docker.pkg.dev/${PROJECT_ID}/${REPOSITORY_NAME}/book-details-app:${TAG}
docker run -d -p 8082:8080 ${REPOSITORY_REGION}-docker.pkg.dev/${PROJECT_ID}/${REPOSITORY_NAME}/book-reviews-app:${TAG}
docker run -d -p 8083:8080 ${REPOSITORY_REGION}-docker.pkg.dev/${PROJECT_ID}/${REPOSITORY_NAME}/images-app:${TAG}

  2. Comprueba que los contenedores se estén ejecutando. Para ello, muestra todos los contenedores activos:

    docker ps

    El resultado de este comando debería mostrar tres contenedores en ejecución con el estado Up:

    CONTAINER ID   IMAGE                PORTS                        STATUS
a1b2c3d4e5f6   REGION/.../details   0.0.0.0:8081->8080/tcp       Up
g7h8i9j0k1l2   REGION/.../reviews   0.0.0.0:8082->8080/tcp       Up
m3n4o5p6q7r8   REGION/.../images    0.0.0.0:8083->8080/tcp       Up

  3. Para probar los endpoints del contenedor book_details_app, usa los siguientes comandos curl:

    curl http://localhost:8081/books
curl http://localhost:8081/book/1
curl http://localhost:8081/book/2
curl http://localhost:8081/book/3

    Cada uno de estos comandos devuelve datos en formato JSON. Por ejemplo, el resultado del comando curl http://localhost:8081/book/1 tiene el siguiente aspecto:

    {"author":"Aria Clockwork","description":"In a world where time is a tangible substance, a young clockmaker discovers she can manipulate the fabric of time itself, leading to unforeseen consequences in her steampunk-inspired city.","id":1,"image_url":"zephyrs_timepiece.jpg","title":"Zephyr's Timepiece","year":2023}

  4. Recupera las reseñas del libro del contenedor book_reviews_app con este comando curl:

    curl http://localhost:8082/book/1/reviews

    Este comando devuelve una lista de 20 reseñas del libro 1 en formato JSON. A continuación se muestra un ejemplo de una reseña de la lista:

    {
"content": "The concept of time as a tangible substance is brilliantly explored in 'Zephyr's Timepiece'.",
"rating": 5
}

  5. Prueba el contenedor images_app:

    1. Haz clic en el botón **Web Preview**. Botón Vista previa web

    2. Selecciona Cambiar puerto e introduce 8083. Se abrirá una ventana del navegador con una URL similar a esta:

      https://8083-your-instance-id.cs-your-region.cloudshell.dev/?authuser=0

    3. Quita ?authuser=0 al final de la URL y añade la ruta a un archivo de imagen, como /images/fungi_frontier.jpg. A continuación, se muestra un ejemplo:

      https://8083-your-instance-id.cs-your-region.cloudshell.dev/images/fungi_frontier.jpg

      Deberías ver la imagen de portada del libro Fungi Frontier en tu navegador.

  6. Después de las pruebas, detén los contenedores para liberar recursos:

    1. Lista los contenedores en ejecución y busca sus IDs de contenedor:

      docker ps

    2. Detener cada contenedor:

      docker stop CONTAINER_ID

      Sustituye CONTAINER_ID por el ID del contenedor que quieras detener.

Enviar las imágenes de contenedor a Artifact Registry

Antes de poder desplegar tu aplicación en un clúster de Kubernetes, las imágenes de contenedor deben almacenarse en una ubicación a la que pueda acceder el clúster. En este paso, debes enviar las imágenes al repositorio de Artifact Registry que has creado anteriormente. En el siguiente tutorial, desplegarás esas imágenes desde el repositorio de Artifact Registry en un clúster de GKE:

  1. Para enviar tus imágenes de contenedor a Artifact Registry, ejecuta estos comandos:

    docker push ${REPOSITORY_REGION}-docker.pkg.dev/${PROJECT_ID}/${REPOSITORY_NAME}/home-app:${TAG}
docker push ${REPOSITORY_REGION}-docker.pkg.dev/${PROJECT_ID}/${REPOSITORY_NAME}/book-details-app:${TAG}
docker push ${REPOSITORY_REGION}-docker.pkg.dev/${PROJECT_ID}/${REPOSITORY_NAME}/book-reviews-app:${TAG}
docker push ${REPOSITORY_REGION}-docker.pkg.dev/${PROJECT_ID}/${REPOSITORY_NAME}/images-app:${TAG}

  2. Después de enviar las imágenes, comprueba que se han subido correctamente enumerándolas:

    gcloud artifacts docker images list ${REPOSITORY_REGION}-docker.pkg.dev/${PROJECT_ID}/${REPOSITORY_NAME}

    Debería aparecer lo siguiente:

    Listing items under project ${PROJECT_ID}, location ${REPOSITORY_REGION}, repository ${REPOSITORY_NAME}.

IMAGE: ${REPOSITORY_REGION}-docker.pkg.dev/${PROJECT_ID}/${REPOSITORY_NAME}/book-details-app
DIGEST: sha256:f7b78f44d70f2eedf7f7d4dc72c36070e7c0dd05daa5f473e1ebcfd1d44b95b1
CREATE_TIME: 2024-11-14T00:38:53
UPDATE_TIME: 2024-11-14T00:38:53
SIZE: 52260143

IMAGE: ${REPOSITORY_REGION}-docker.pkg.dev/${PROJECT_ID}/${REPOSITORY_NAME}/book-reviews-app
DIGEST: sha256:875ac8d94ef54db2ff637e49ad2d1c50291087623718b854a34ad657748fac86
CREATE_TIME: 2024-11-14T00:39:04
UPDATE_TIME: 2024-11-14T00:39:04
SIZE: 52262041

IMAGE: ${REPOSITORY_REGION}-docker.pkg.dev/${PROJECT_ID}/${REPOSITORY_NAME}/home-app
DIGEST: sha256:70ddc54ffd683e2525d87ee0451804d273868c7143d0c2a75ce423502c10638a
CREATE_TIME: 2024-11-14T00:33:56
UPDATE_TIME: 2024-11-14T00:33:56
SIZE: 52262412

IMAGE: ${REPOSITORY_REGION}-docker.pkg.dev/${PROJECT_ID}/${REPOSITORY_NAME}/images-app
DIGEST: sha256:790f0d8c2f83b09dc3b431c4c04d7dc68254fecc76c48f00a83babc2a5dc0484
CREATE_TIME: 2024-11-14T00:39:15
UPDATE_TIME: 2024-11-14T00:39:15
SIZE: 53020815

    El resultado incluye los siguientes detalles de cada imagen:

    • IMAGEN: la ruta del repositorio y el nombre de la imagen.
    • DIGEST: identificador único de la imagen.
    • CREATE_TIME o UPDATE_TIME: cuándo se creó o se modificó por última vez la imagen.
    • SIZE: el tamaño de la imagen en bytes.

Actualizar el manifiesto de Kubernetes con las rutas a las imágenes de contenedor

Como has visto en el tutorial anterior, Prepara la aplicación modular para la contenedorización, un manifiesto de Kubernetes es un archivo YAML que define cómo se ejecuta tu aplicación en un clúster de Kubernetes. Incluye detalles como los siguientes:

  • Los módulos de tu aplicación (por ejemplo, home-app o book-details-app)
  • Rutas a las imágenes de contenedor
  • Detalles de configuración, como los límites de recursos
  • Definiciones de servicio para enrutar solicitudes entre módulos

En esta sección, actualizarás el mismo archivo de manifiesto que has revisado en el tutorial anterior. El archivo es kubernetes-manifest.yaml y contiene valores de marcador de posición para las rutas de las imágenes. Debe sustituir esos marcadores de posición por las rutas reales de las imágenes de contenedor que ha enviado a su repositorio de Artifact Registry en la sección anterior.

Para actualizar el archivo de manifiesto de kubernetes-manifest.yaml Kubernetes, sigue estos pasos:

  1. En Cloud Shell, ve al directorio containerized/, que contiene el archivo de manifiesto de Kubernetes kubernetes-manifest.yaml:

    cd kubernetes-engine-samples/quickstarts/monolith-to-microservices/containerized/

  2. Abre el archivo kubernetes-manifest.yaml en un editor de texto:

    vim kubernetes-manifest.yaml

  3. Busca los campos image que contengan marcadores de posición como este:

    image: REPOSITORY_REGION-docker.pkg.dev/PROJECT_ID/REPOSITORY_NAME/home-app:TAG

    Sustituye cada marcador de posición por las rutas reales de las imágenes de contenedor que has enviado a Artifact Registry:

    Este es el aspecto que podría tener una ruta después de hacer estos reemplazos:

    image:us-west1-docker.pkg.dev/your-project-id/book-review-service-repo/home-app:v1

  4. Actualiza las rutas de todas las imágenes de contenedor:

    • home-app
    • book-details-app
    • book-reviews-app
    • images-app

  5. Después de actualizar las rutas, guarda el archivo de manifiesto y cierra el editor. Por ejemplo, si usas vim, pulsa Esc para entrar en el modo de comandos, escribe wq y pulsa Intro para guardar y salir.

El manifiesto de Kubernetes ya está configurado para desplegar las imágenes de contenedor de tu repositorio de Artifact Registry en un clúster de Kubernetes.

Resumen

En este tutorial, has preparado la aplicación modular Cymbal Books para desplegarla en un clúster de Kubernetes realizando las siguientes tareas:

  1. Configurar un Google Cloud proyecto y Cloud Shell para tu entorno.
  2. Revisar los archivos Dockerfile proporcionados para cada módulo de la aplicación.
  3. Crea imágenes de contenedor para los módulos de la aplicación mediante Docker.
  4. Se han probado contenedores en Cloud Shell para verificar su funcionalidad.
  5. Se han enviado las imágenes de contenedor a Artifact Registry para almacenarlas.
  6. Se ha actualizado el manifiesto de Kubernetes para usar las rutas de imagen de contenedor correctas de Artifact Registry.

Siguientes pasos

En el siguiente tutorial, Desplegar la aplicación en un clúster de GKE, desplegarás la aplicación en contenedores en un clúster de GKE.