Ruta de aprendizaje: Transforma un monolítico en una app de GKE: Aloja en contenedores la app modular

Este es el cuarto instructivo de una ruta de aprendizaje que te enseña a modularizar y alojar en contenedores una app monolítica.

La ruta de aprendizaje consta de los siguientes instructivos:

  1. Descripción general
  2. Comprende la aplicación monolítica
  3. Modulariza la aplicación monolítica
  4. Prepara la app modular para la organización en contenedores
  5. Organiza en contenedores la app modular (este instructivo)
  6. Implementa la app en un clúster de GKE

En el instructivo anterior, Prepara la app modular para la contenerización, viste qué cambios debían realizarse en la versión modular de la app de Cymbal Books para prepararla para la contenerización. En este instructivo, alojarás la app en un contenedor.

Costos

Puedes completar este instructivo sin incurrir en cargos. Sin embargo, seguir los pasos del próximo instructivo de esta serie generará cargos en tu cuenta deGoogle Cloud . Los costos comienzan cuando habilitas GKE y, luego, implementas la app de Cymbal Books en un clúster de GKE. Estos costos incluyen los cargos por clúster de GKE, como se describe en la página de precios, y los cargos por ejecutar VMs de Compute Engine.

Para evitar cargos innecesarios, asegúrate de inhabilitar GKE o borrar el proyecto una vez que hayas completado este instructivo.

Antes de comenzar

Antes de comenzar con este instructivo, asegúrate de haber completado los instructivos anteriores de la serie. Para obtener una descripción general de toda la serie y vínculos a tutoriales específicos, consulta Ruta de aprendizaje: Transforma un monolito en una app de GKE: Descripción general.

Configura tu entorno

En esta sección, configurarás un entorno en el que contenerizarás la app modular. Específicamente, realizarás los siguientes pasos:

  1. Selecciona o crea un Google Cloud proyecto
  2. Habilita las APIs necesarias
  3. Conecta Cloud Shell a tu proyecto Google Cloud
  4. Configura las variables de entorno predeterminadas
  5. Crea un repositorio en Artifact Registry
  6. Configura Docker para Artifact Registry
  7. Obtén el código del instructivo

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.

    Go to project selector

  2. Make sure that billing is enabled for your Google Cloud project.

Habilita las API necesarias

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

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

Para habilitar estas APIs, visita habilita las APIs en la consola de Google Cloud .

Conecta Cloud Shell a tu proyecto de Google Cloud

Ahora que configuraste tu proyecto Google Cloud , debes iniciar una instancia deCloud Shell y conectarla a tu proyecto Google Cloud. Cloud Shell es una herramienta de línea de comandos que te permite crear y administrar los recursos de un proyecto directamente desde tu navegador. Cloud Shell ya viene instalado con dos herramientas importantes: la CLI de gcloud y la CLI de kubectl. En este instructivo, usarás gcloud CLI para interactuar con Google Cloud y, en el siguiente, usarás la CLI de kubectl para administrar la app de Cymbal Books que se ejecuta en GKE.

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

  1. Ve a la consola de Google Cloud :

    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 dentro de un marco en la parte inferior en la consola.

  3. Configura tu proyecto predeterminado en Google Cloud CLI con el siguiente comando:

    gcloud config set project PROJECT_ID

    Reemplaza PROJECT_ID por el ID del proyecto que creaste o seleccionaste en la sección anterior, Selecciona o crea Google Cloud proyecto. Un ID del proyecto es una cadena única que diferencia tu proyecto de todos los demás proyectos en Google Cloud. Para ubicar el ID del proyecto, ve al selector de proyectos. En esa página, puedes ver los IDs de cada uno de tus proyectos de Google Cloud.

Configura las variables de entorno predeterminadas

Para simplificar los comandos que ejecutarás a lo largo de este instructivo, ahora establecerás algunas variables de entorno en Cloud Shell. Estas variables almacenan valores como el ID del proyecto, la región del repositorio y la etiqueta de la imagen. Después de definir estas variables, puedes volver a usarlas en varios comandos haciendo referencia al nombre de la variable (por ejemplo, $REPOSITORY_NAME) en lugar de volver a escribir o reemplazar los valores cada vez. Este enfoque facilita el seguimiento del instructivo y 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

Reemplaza lo siguiente:

  • REPOSITORY_REGION: Es la región en la que deseas que se aloje tu repositorio de Artifact Registry. Por ejemplo, us-central1 (Iowa), us-west1 (Oregón) o europe-west1 (Bélgica). Para obtener 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: Es la etiqueta que deseas aplicar a una imagen. Una etiqueta es una etiqueta que puedes adjuntar 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
    • Es una etiqueta que indica el entorno, como test.

Crea un repositorio en Artifact Registry

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

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}"

El resultado correcto del comando se ve de la siguiente manera:

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

Configura Docker para Artifact Registry

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

Si no configuras Docker de esta manera, no podrás enviar las imágenes de contenedor a Artifact Registry (una tarea que realizarás más adelante en este instructivo). Tampoco puedes extraer las imágenes de contenedor de Artifact Registry y, luego, implementarlas en un clúster de GKE (una tarea que realizarás en el próximo instructivo).

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

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

Obtén el código del instructivo

Ahora que tu entorno de Cloud Shell está configurado, debes descargar el código del instructivo en Cloud Shell. Incluso si clonaste el repositorio en tu máquina local, debes volver a clonarlo aquí en tu instancia de Cloud Shell.

Si bien es posible completar este instructivo en tu máquina local, deberás instalar y configurar manualmente varias herramientas, como Docker, kubectl y gcloud CLI. Usar Cloud Shell es más fácil 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 contenedores, contenedores y Dockerfiles

Ahora que configuraste tu entorno y descargaste el código en contenedores, puedes crear contenedores para la app. Esto consiste en usar un Dockerfile para empaquetar cada módulo de Cymbal Books (página principal, detalles del libro, imágenes y reseñas del libro) en una imagen de contenedor. Cuando la aplicación se implementa 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 contenedorización?

La creación de 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 la laptop de un desarrollador hasta un servidor de pruebas o un clúster de Kubernetes de producción.

¿Qué son las imágenes de contenedores?

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 instructivo, crearás una imagen de contenedor para cada módulo de la app 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 maneras: con el comando docker run para realizar pruebas durante el desarrollo o implementando imágenes de contenedor en un clúster de Kubernetes.

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

  • El contenedor de la página principal ejecuta el módulo de la página principal y controla las solicitudes a /.
  • El contenedor de detalles del libro ejecuta el módulo de detalles del libro y entrega datos para extremos como /book/1 o /book/3.
  • El contenedor de opiniones sobre libros ejecuta el módulo de opiniones sobre libros y administra las solicitudes a extremos como /book/2/reviews.
  • El contenedor de imágenes ejecuta el módulo de imágenes y entrega imágenes de portadas de libros para extremos como /images/fungi_frontier.jpg.

Una ventaja clave de los contenedores es que Kubernetes puede crear automáticamente más contenedores cuando sea necesario. Por ejemplo, si muchos usuarios leen reseñas de libros, Kubernetes puede iniciar contenedores adicionales de reseñas de libros para controlar la carga.

Para implementar el ajuste de escala en una app modular que no usa contenedores, deberás escribir código personalizado para iniciar instancias nuevas de un módulo y distribuir el tráfico entre ellas. Con Kubernetes, esta capacidad de escalamiento está integrada: no necesitas escribir ningún código de escalamiento 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 instructivo, no es necesario que crees ningún Dockerfile, ya que se te proporcionan en el repositorio de GitHub que clonaste antes. El directorio de cada módulo en 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 se ve de la siguiente manera:

# 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 del contenedor para el módulo home_app:

  • Línea 1: FROM python:3.9-slim descarga un intérprete de Python 3.9 y sus archivos obligatorios 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 establece este directorio 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 de contenedor. En el archivo requirements.txt, se enumeran todas las bibliotecas de Python que necesita home_app.py. 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 dentro 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"] le 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 la contenerización puede aplicar un aislamiento de datos más estricto

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

Aquí, en la versión en contenedores de la app, el contenedor de cada módulo incluye solo los archivos necesarios. Por ejemplo, si el módulo home_app no necesita acceso a los datos de opiniones sobre libros, esos datos simplemente no existen dentro del 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 hacerlo. Esto ayuda a garantizar que cada módulo esté completamente aislado y también ayuda a evitar el acceso accidental o no autorizado a los datos.

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

Compila imágenes de contenedor con Docker

En esta sección, compilarás imágenes de contenedor de Docker para cada uno de los módulos de revisión de libros y las enviarás a tu repositorio de Artifact Registry. Usarás estas imágenes de contenedor en un instructivo posterior para implementar y ejecutar la app de ejemplo de Cymbal Books en Kubernetes.

  1. Navega al directorio raíz de la aplicación alojada en el 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. Visualiza las imágenes de contenedor que se compilaron dentro de tu instancia de Cloud Shell:

    docker images

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

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

    Si se muestran las cuatro imágenes, significa que creaste las imágenes de contenedor correctamente.

Prueba contenedores en Cloud Shell

Para verificar que las imágenes del contenedor se compilen correctamente, puedes ejecutarlas como contenedores y probar sus extremos en Cloud Shell.

Los contenedores book_details_app, book_reviews_app y images_app se pueden probar de forma individual 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.

Si bien es posible probar el contenedor home_app buscando la dirección IP de cada contenedor y configurando home_app para que los use en lugar de los nombres de servicio, este enfoque requiere mucho esfuerzo. En su lugar, es una buena idea aplazar la prueba del contenedor home_app hasta después de implementar la aplicación en un clúster de Kubernetes. Una vez que la app esté en el clúster, puedes determinar si el módulo principal 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. Para verificar que los contenedores se estén ejecutando, enumera 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 extremos 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 se ve de la siguiente manera:

    {"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 opiniones sobre libros del contenedor book_reviews_app con este comando curl:

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

    Este comando devuelve una lista de 20 opiniones sobre el libro 1 en formato JSON. A continuación, se muestra un ejemplo de una opinión 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 en la Web

    2. Selecciona Cambiar puerto y, luego, ingresa 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 agrega la ruta de acceso 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 la portada del libro Fungi Frontier en tu navegador.

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

    1. Enumera los contenedores en ejecución y busca sus IDs:

      docker ps

    2. Detén cada contenedor:

      docker stop CONTAINER_ID

      Reemplaza CONTAINER_ID por el ID del contenedor que deseas detener.

Envía las imágenes de contenedor a Artifact Registry

Antes de implementar tu app en un clúster de Kubernetes, las imágenes de contenedor deben almacenarse en una ubicación a la que el clúster pueda acceder. En este paso, enviarás las imágenes al repositorio de Artifact Registry que creaste anteriormente. En el siguiente instructivo, implementará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, verifica que se hayan subido correctamente enumerándolas:

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

    Debería ver un resultado similar al 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 para cada imagen:

    • IMAGE: Es la ruta de acceso al repositorio y el nombre de la imagen.
    • RESUMEN: Es un identificador único de la imagen.
    • CREATE_TIME o UPDATE_TIME: Indica cuándo se creó o modificó por última vez la imagen.
    • SIZE: Es el tamaño de la imagen en bytes.

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

Como aprendiste en el instructivo anterior, Prepara la app modular para la contenerización, un manifiesto de Kubernetes es un archivo YAML que define cómo se ejecuta tu app en un clúster de Kubernetes. Incluye detalles como los siguientes:

  • Los módulos de tu app (por ejemplo,home-app, book-details-app)
  • Rutas de acceso a las imágenes de contenedor
  • Detalles de configuración, como 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 revisaste en el instructivo anterior. Ese archivo es kubernetes-manifest.yaml y contiene valores de marcador de posición para las rutas de acceso a las imágenes. Debes reemplazar esos marcadores de posición por las rutas de acceso reales a las imágenes de contenedor que enviaste a tu repositorio de Artifact Registry en la sección anterior.

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

  1. En Cloud Shell, navega 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. Ubica los campos image que contienen marcadores de posición como este:

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

    Reemplaza cada marcador de posición por las rutas de acceso reales a las imágenes de contenedor que enviaste a Artifact Registry:

    Así podría verse una ruta después de realizar estos reemplazos:

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

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

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

  5. Después de actualizar las rutas de acceso, guarda el archivo de manifiesto y cierra el editor. Por ejemplo, si usas vim, presiona Esc para ingresar al modo de comando, escribe wq y presiona Intro para guardar y salir.

Ahora, tu manifiesto de Kubernetes está configurado para implementar las imágenes de contenedor de tu repositorio de Artifact Registry en un clúster de Kubernetes.

Resumen

En este instructivo, preparaste la app modular Cymbal Books para su implementación en un clúster de Kubernetes realizando las siguientes tareas:

  1. Configura un proyecto Google Cloud y Cloud Shell para tu entorno.
  2. Revisé los archivos Dockerfile proporcionados para cada módulo de la app.
  3. Se compilaron imágenes de contenedor para los módulos de la app con Docker.
  4. Probé contenedores en Cloud Shell para verificar su funcionalidad.
  5. Se enviaron las imágenes de contenedor a Artifact Registry para su almacenamiento.
  6. Se actualizó el manifiesto de Kubernetes para usar las rutas de acceso correctas a las imágenes de contenedor de Artifact Registry.

¿Qué sigue?

En el siguiente instructivo, Implementa la app en un clúster de GKE, implementarás la aplicación en contenedores en un clúster de GKE.