GSP699

Descripción general

¿Por qué migrar una aplicación monolítica a una arquitectura de microservicios? Desglosar una aplicación en microservicios tiene las siguientes ventajas, cuya mayoría se debe a que los microservicios están vinculados de manera flexible:

• Los microservicios se pueden implementar y probar de forma independiente. Cuanto más pequeña sea la unidad de implementación, más fácil será la implementación.
• Se pueden implementar en diferentes lenguajes y frameworks. En cada microservicio, puedes elegir la mejor tecnología para tu caso práctico en particular.
• Los pueden administrar diferentes equipos. El límite entre microservicios facilita que un equipo se dedique a uno o varios microservicios.
• Mediante la migración a los microservicios, puedes flexibilizar las dependencias entre los equipos. Cada equipo debe preocuparse solo por las API de los microservicios de los que dependen. El equipo no necesita pensar en cómo se implementan esos microservicios, en sus ciclos de lanzamiento, etcétera.
• Puedes lograr diseños para evitar fallas con más facilidad. Si hay límites entre los servicios, es más fácil determinar qué hacer si un servicio está inactivo.

Estas son algunas desventajas en comparación con las aplicaciones monolíticas:

• Debido a que una aplicación basada en microservicios es una red de servicios diferentes que a menudo interactúan de maneras que no son evidentes, la complejidad general del sistema suele ser mayor.
• A diferencia de los componentes internos de una aplicación monolítica, los microservicios se comunican por medio de una red. En algunas circunstancias, esto puede considerarse un problema de seguridad. Istio resuelve este problema mediante la encriptación automática del tráfico entre microservicios.
• Lograr el mismo nivel de rendimiento que se obtiene con un enfoque monolítico puede resultar difícil debido a las latencias entre servicios.
• El comportamiento de tu sistema no se debe a un solo servicio, sino a muchos de ellos y a sus interacciones. Por esta razón, es más difícil comprender cómo se comporta tu sistema en la producción (su observabilidad). Istio también representa una solución a este problema.

En este lab, implementarás una aplicación monolítica existente en un clúster de Google Kubernetes Engine y, luego, la desglosarás en microservicios. Kubernetes es una plataforma para administrar, alojar, implementar y escalar contenedores. Los contenedores son una forma portátil de empaquetar y ejecutar código. Son adecuados para el patrón de microservicios, en el que cada microservicio puede ejecutarse en su propio contenedor.

Diagrama de la arquitectura de nuestros microservicios

Comienza por desglosar la aplicación monolítica en tres microservicios, uno a la vez. Los microservicios incluyen Pedidos, Productos y Frontend. Compila una imagen de Docker para cada microservicio con Cloud Build, luego implementa y expón los microservicios en Google Kubernetes Engine (GKE) con un tipo de servicio LoadBalancer de Kubernetes. Harás esto para cada servicio mientras los refactorizas, en simultáneo, fuera de la aplicación monolítica. Durante el proceso, tendrás en ejecución tanto la aplicación monolítica como los microservicios hasta el final, cuando puedas borrar la aplicación monolítica.

Qué aprenderás

• Cómo desglosar una aplicación monolítica en microservicios
• Cómo crear un clúster de Google Kubernetes Engine
• Cómo crear una imagen de Docker
• Cómo implementar imágenes de Docker en Kubernetes

Requisitos previos

• Una cuenta de Google Cloud con acceso de administrador para crear proyectos o un proyecto con el rol Propietario del proyecto
• Conocimientos básicos de Docker y Kubernetes

Configuración y requisitos

Antes de hacer clic en el botón Comenzar lab

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

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

Para completar este lab, necesitarás lo siguiente:

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

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

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

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

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

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

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

2. Haz clic en Abrir la consola de Google Cloud (o haz clic con el botón derecho y selecciona Abrir el vínculo en una ventana de incógnito si ejecutas el navegador Chrome).

   El lab inicia recursos y abre otra pestaña en la que se muestra la página de acceso.

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

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

3. De ser necesario, copia el nombre de usuario a continuación y pégalo en el diálogo Acceder.

   {{{user_0.username | "Username"}}}

   También puedes encontrar el nombre de usuario en el panel Detalles del lab.

4. Haz clic en Siguiente.

5. Copia la contraseña que aparece a continuación y pégala en el diálogo Te damos la bienvenida.

   {{{user_0.password | "Password"}}}

   También puedes encontrar la contraseña en el panel Detalles del lab.

6. Haz clic en Siguiente.

   Importante: Debes usar las credenciales que te proporciona el lab. No uses las credenciales de tu cuenta de Google Cloud. Nota: Usar tu propia Cuenta de Google podría generar cargos adicionales.

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

   • Acepta los Términos y Condiciones.
   • No agregues opciones de recuperación o autenticación de dos factores (esta es una cuenta temporal).
   • No te registres para obtener pruebas gratuitas.

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

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

Activa Cloud Shell

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

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

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

Your Cloud Platform project in this session is set to YOUR_PROJECT_ID

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

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

gcloud auth list

3. Haz clic en Autorizar.

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

Resultado:

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

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

gcloud config list project

Resultado:

[core] project = <project_ID>

Resultado de ejemplo:

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

Establece la zona predeterminada y la configuración del proyecto:

gcloud config set compute/zone {{{project_0.default_zone | (zone)}}}

Tarea 1. Clona el repositorio de código fuente

Usarás una aplicación monolítica existente de un sitio web de comercio electrónico imaginario, con una página de bienvenida simple, una página de productos y una página de historial de pedidos. Solo tendremos que clonar el origen de nuestro repo de Git, así podremos enfocarnos en desglosarlo en microservicios para implementarlos en Google Kubernetes Engine (GKE).

• Ejecuta los siguientes comandos para clonar el repositorio de Git en la instancia de Cloud Shell y cambiarlo al directorio correspondiente. También, instalarás las dependencias de Node.js para poder probar tu aplicación monolítica antes de implementarla:

cd ~ git clone https://github.com/googlecodelabs/monolith-to-microservices.git cd ~/monolith-to-microservices ./setup.sh

Es posible que la ejecución de esta secuencia de comandos tarde unos minutos.

Tarea 2. Crea un clúster de GKE

Ahora que tienes tu entorno de desarrollo activo, necesitas un clúster de Kubernetes para implementar primero tu aplicación monolítica y, luego, los microservicios también. Antes de crear un clúster, asegúrate de que estén habilitadas las APIs correspondientes.

1. Ejecuta el siguiente comando para habilitar la API de los contenedores y, así, poder usar Google Kubernetes Engine:

gcloud services enable container.googleapis.com

2. Ejecuta el comando a continuación para crear un clúster de GKE llamado fancy-cluster con 3 nodos:

gcloud container clusters create fancy-cluster --num-nodes 3 --machine-type=e2-standard-4 Advertencia: Si recibes un error acerca de que no se especificó la región/zona, consulta la sección de configuración del entorno para asegurarte de configurar la zona de procesamiento predeterminada.

La creación del clúster puede demorar varios minutos.

3. Una vez que se completó el proceso, ejecuta el siguiente comando para ver las tres instancias de VM de trabajador del clúster:

gcloud compute instances list

Resultado:

NAME ZONE MACHINE_TYPE PREEMPTIBLE INTERNAL_IP EXTERNAL_IP STATUS gke-fancy-cluster-default-pool-ad92506d-1ng3 {{{project_0.default_zone | (zone)}}} e2-standard-4 10.150.0.7 XX.XX.XX.XX RUNNING gke-fancy-cluster-default-pool-ad92506d-4fvq {{{project_0.default_zone | (zone)}}} e2-standard-4 10.150.0.5 XX.XX.XX.XX RUNNING gke-fancy-cluster-default-pool-ad92506d-4zs3 {{{project_0.default_zone | (zone)}}} e2-standard-4 10.150.0.6 XX.XX.XX.XX RUNNING

También, puedes ver tu clúster de Kubernetes y la información relacionada en la consola de Cloud. En Menú de navegación, desplázate hacia abajo hasta Kubernetes Engine y haz clic en Clústeres.

Deberías ver tu clúster llamado fancy-cluster.

¡Felicitaciones! Acabas de crear tu primer clúster de Kubernetes.

Haz clic en Revisar mi progreso para verificar el objetivo. Crea un clúster de GKE

Tarea 3. Implementa la aplicación monolítica existente

Debido a que este lab se enfoca en el desglose de una aplicación monolítica en microservicios, necesitas tener una aplicación monolítica en funcionamiento.

• Ejecuta la siguiente secuencia de comandos para implementar una aplicación monolítica en tu clúster de GKE:

cd ~/monolith-to-microservices ./deploy-monolith.sh

Accede a la aplicación monolítica

1. Para encontrar la dirección IP externa de la aplicación monolítica, ejecuta el siguiente comando:

kubectl get service monolith

Deberías ver un resultado similar al siguiente:

NAME CLUSTER-IP EXTERNAL-IP PORT(S) AGE monolith 10.3.251.122 203.0.113.0 80:30877/TCP 3d

2. Si tu resultado muestra la IP externa como <pending>, espera un minuto y vuelve a ejecutar el comando.

3. Una vez que hayas determinado la dirección IP externa para tu aplicación monolítica, cópiala y escribe esta URL (como http://203.0.113.0) en tu navegador para verificar si se puede acceder a ella.

Nota: Recuerda esta dirección IP porque la usarás en el futuro. Siempre puedes volver a encontrarla a través de este mismo comando.

Deberías ver la página de bienvenida del sitio web monolítico. La Página de bienvenida es una página estática que será entregada por el microservicio Frontend más adelante. Tu aplicación monolítica ya se está ejecutando por completo en Kubernetes.

Haz clic en Revisar mi progreso para verificar el objetivo. Implementa la aplicación monolítica existente

Tarea 4. Migra pedidos a un microservicio

Ahora que tienes un sitio web monolítico ejecutándose en GKE, comienza a desglosar cada servicio en un microservicio. Por lo general, tendrás que planificar qué servicios separar en partes más pequeñas, normalmente en torno a partes específicas de la aplicación, como el dominio de la empresa.

Para este lab, crearás un ejemplo y separarás cada servicio en torno al dominio de la empresa: Pedidos, Productos y Frontend. Como el código ya se migró, puedes enfocarte en compilar e implementar los servicios en Google Kubernetes Engine (GKE).

Crea un nuevo microservicio Pedidos

El primer servicio que desglosarás será Pedidos. Usa la base de código separada que se proporciona y crea otro contenedor de Docker para este servicio.

Crea un contenedor de Docker con Cloud Build

Como la base de código ya está disponible, tu primer paso será crear un contenedor de Docker para tu servicio Pedidos con Cloud Build.

En situaciones normales, esto se hace mediante un proceso de dos pasos que implica compilar un contenedor de Docker y enviarlo a un registro para almacenar la imagen que extraerá GKE. Cloud Build se puede usar para compilar el contenedor de Docker y colocar la imagen en Container Registry con un único comando. Esto te permite ejecutar un solo comando para compilar tu imagen y moverla a Container Registry. Para obtener información sobre el proceso manual de creación de un archivo Docker y su envío, puedes ir a la documentación de Google Cloud Container Registry y ver la Guía de inicio rápido para Container Registry.

Google Cloud Build comprimirá los archivos del directorio y los moverá a un bucket de Cloud Storage. Luego, el proceso de compilación tomará todos los archivos del bucket y usará el Dockerfile para ejecutar el proceso de compilación de Docker. Como la marca --tag se especifica con el host como gcr.io para la imagen de Docker, se enviará la imagen de Docker resultante a Google Cloud Container Registry.

1. Ejecuta los siguientes comandos para compilar tu contenedor de Docker y enviarlo a Google Container Registry:

cd ~/monolith-to-microservices/microservices/src/orders gcloud builds submit --tag gcr.io/${GOOGLE_CLOUD_PROJECT}/orders:1.0.0 .

Este proceso tardará un minuto en completarse, pero cuando haya finalizado, se mostrará un resultado similar al siguiente en la terminal:

----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- ID CREATE_TIME DURATION SOURCE IMAGES STATUS 1ae295d9-63cb-482c-959b-bc52e9644d53 2019-08-29T01:56:35+00:00 33S gs://_cloudbuild/source/1567043793.94-abfd382011724422bf49af1558b894aa.tgz gcr.io//orders:1.0.0 SUCCESS

2. Para ver tu historial de compilaciones o el proceso en tiempo real en la consola, haz clic en el menú de navegación, en la parte superior izquierda, y desplázate hacia abajo hasta CI/CD y, luego, haz clic en Cloud Build > Historial. Aquí, podrás ver una lista de todas tus compilaciones anteriores. Debería haber una sola recién creada.

Si haces clic en el ID de compilación, puedes ver todos sus detalles, incluida la salida del registro.

Para ver la imagen del contenedor que se creó, dirígete a la página de detalles de compilación, haz clic en la pestaña Detalles de la ejecución, en la sección derecha, y mira en Imagen.

Implementa el contenedor en GKE

Ahora que alojaste el sitio web en contenedores y lo enviaste a Google Container Registry, es hora de implementarlo en Kubernetes.

Kubernetes representa aplicaciones como Pods, que son unidades que representan un contenedor (o grupo de contenedores estrechamente vinculados). Un Pod es la unidad más pequeña que se puede implementar en Kubernetes. En este instructivo, cada Pod contiene solo tu contenedor de microservicios.

Para implementar y administrar aplicaciones en un clúster de GKE, debes comunicarte con el sistema de administración de clústeres de Kubernetes. Normalmente, esto se hace con la herramienta de línea de comandos kubectl desde Cloud Shell.

Primero, crea un recurso Deployment. Este recurso administra varias copias de tu aplicación, que se llaman réplicas, y las programa para que se ejecuten en los nodos individuales de tu clúster. En este caso, Deployment ejecutará solo un Pod de tu aplicación. Los recursos Deployment crean un ReplicaSet para garantizar esto. El ReplicaSet debe asegurarse de que la cantidad especificada de réplicas siempre esté en ejecución.

El comando kubectl create deployment que figura a continuación hace que Kubernetes cree un Deployment, llamado Pedidos en tu clúster con 1 réplica.

• Ejecuta el siguiente comando para implementar tu aplicación:

kubectl create deployment orders --image=gcr.io/${GOOGLE_CLOUD_PROJECT}/orders:1.0.0 Nota: Como práctica recomendada, se recomienda utilizar un archivo YAML para declarar tu cambio en el clúster de Kubernetes (por ejemplo, crear o modificar una implementación o servicio) y un sistema de control de código fuente como GitHub o Cloud Source Repositories para almacenar esos cambios. Puedes obtener más información sobre esto en la Documentación de Kubernetes Deployments.

Verifica la implementación

• Para verificar que el recurso Deployment se haya creado correctamente, ejecuta el siguiente comando:

kubectl get all

El estado del Pod puede tardar unos minutos en cambiar a “Running”.

Resultado:

NAME READY STATUS RESTARTS AGE pod/monolith-779c8d95f5-dxnzl 1/1 Running 0 15h pod/orders-5bc6969d76-kdxkk 1/1 Running 0 21s NAME TYPE CLUSTER-IP EXTERNAL-IP PORT(S) AGE service/kubernetes ClusterIP 10.39.240.1 443/TCP 19d service/monolith LoadBalancer 10.39.241.130 34.74.209.57 80:30412/TCP 15h NAME READY UP-TO-DATE AVAILABLE AGE deployment.apps/monolith 1/1 1 1 15h deployment.apps/orders 1/1 1 1 21s NAME DESIRED CURRENT READY AGE replicaset.apps/monolith-779c8d95f5 1 1 1 15h replicaset.apps/orders-5bc6969d76 1 1 1 21s

Puedes ver tu recurso Deployment actual (CURRENT), el replicaset con el recuento de Pods deseado (DESIRED) de 1 y el Pod en ejecución (Running). Todo indica que la creación se realizó correctamente.

También, puedes ver tus recursos Deployment de Kubernetes en la consola de Cloud desde Menú de navegación > Kubernetes Engine > Cargas de trabajo.

Expón el contenedor de GKE

Ya implementamos nuestra aplicación en GKE, pero no tenemos manera de acceder a ella desde fuera del clúster. Según la configuración predeterminada, los contenedores que ejecutas en GKE no son accesibles desde Internet, ya que no tienen direcciones IP externas. Debes exponer tu aplicación al tráfico de Internet de forma explícita mediante un recurso Service. Este recurso proporciona herramientas de redes y compatibilidad con IP a los Pods de tu aplicación. GKE crea una IP externa y un balanceador de cargas (sujeto a la facturación del sitio web de Google Cloud; revisa los precios de Compute Engine) para tu aplicación.

Para los fines de este lab, se simplificó la exposición del servicio. Por lo general, usarías una puerta de enlace de API para proteger los extremos públicos. En el Centro de Arquitectura de Google Cloud, lee más sobre las prácticas recomendadas para los microservicios.

Cuando implementaste el servicio Pedidos, lo expusiste en el puerto 8081 de forma interna a través de un recurso Deployment de Kubernetes. Para exponer este servicio de forma externa, debes crear un servicio Kubernetes del tipo LoadBalancer para enrutar el tráfico desde el puerto 80 de forma externa al puerto interno 8081.

• Ejecuta el siguiente comando para exponer tu sitio web a Internet:

kubectl expose deployment orders --type=LoadBalancer --port 80 --target-port 8081

Accede al servicio

GKE asigna la dirección IP externa al recurso Service, no a Deployment.

• Si quieres averiguar la IP externa que GKE aprovisionó para tu aplicación, puedes inspeccionar el recurso Service con el comando kubectl get service:

kubectl get service orders

Resultado:

NAME CLUSTER-IP EXTERNAL-IP PORT(S) AGE orders 10.3.251.122 203.0.113.0 80:30877/TCP 3s

Una vez que hayas determinado la dirección IP externa para tu aplicación, cópiala y guárdala para el próximo paso, en el que cambiarás tu aplicación monolítica con el objetivo de que apunte al servicio nuevo Pedidos.

Reconfigura la aplicación monolítica

Como quitaste el servicio Pedidos de la aplicación monolítica, deberás modificar la aplicación monolítica para que apunte al nuevo microservicio externo Pedidos.

Al desglosar una aplicación monolítica, quitas piezas de código de una base de código única, las ubicas en varios microservicios y las implementas por separado. Como los microservicios se ejecutan en un servidor diferente, ya no puedes referenciar las URL de tu servicio como rutas absolutas. Necesitas una ruta a la dirección del servidor del microservicio Pedidos. Esto requerirá que la aplicación monolítica tenga cierto tiempo de inactividad para actualizar la URL de cada servicio que se separó. Debes tener en cuenta esto al planificar la migración de tus microservicios y su aplicación monolítica al entorno de producción durante el proceso de migración de microservicios.

Debes actualizar tu archivo de configuración en la aplicación monolítica para que apunte a la dirección IP del nuevo microservicio Pedidos.

1. Usa el editor nano para reemplazar la URL local por la dirección IP del microservicio Pedidos:

cd ~/monolith-to-microservices/react-app nano .env.monolith

Cuando se abra el editor, tu archivo debería verse de esta forma:

REACT_APP_ORDERS_URL=/service/orders REACT_APP_PRODUCTS_URL=/service/products

2. Reemplaza REACT_APP_ORDERS_URL por el formato nuevo y, a la vez, reemplaza por la dirección IP de tu microservicio Pedidos para que coincida con lo que se muestra a continuación:

REACT_APP_ORDERS_URL=http://<ORDERS_IP_ADDRESS>/api/orders REACT_APP_PRODUCTS_URL=/service/products

3. Presiona CTRL + O, luego INTRO y, por último, CTRL + X para guardar el archivo en el editor nano.

4. Navega por la URL que acabas de establecer en el archivo para probar el microservicio nuevo. La página web debería devolver una respuesta JSON de tu microservicio Pedidos.

5. Luego, vuelve a compilar el frontend de la aplicación monolítica y repite el proceso de compilación del contenedor en la aplicación y vuelve a implementarlo en el clúster de GKE:

• Compila nuevamente los archivos de configuración de la aplicación monolítica:

npm run build:monolith

6. Crea un contenedor de Docker con Cloud Build:

cd ~/monolith-to-microservices/monolith gcloud builds submit --tag gcr.io/${GOOGLE_CLOUD_PROJECT}/monolith:2.0.0 .

7. Implementa el contenedor en GKE:

kubectl set image deployment/monolith monolith=gcr.io/${GOOGLE_CLOUD_PROJECT}/monolith:2.0.0

8. Verifica que la aplicación responde al microservicio Pedidos. Para ello, desde tu navegador, ve a la aplicación monolítica y navega a la página de Pedidos. Todos los ID de pedido deberían terminar con el sufijo -MICROSERVICE, como se muestra a continuación:

9. Haz clic en Revisar mi progreso para verificar el objetivo. Migra Pedidos a un microservicio

Tarea 5. Migra Productos a un microservicio

Crea un microservicio Productos nuevo

Continúa la separación de los servicios con la migración del servicio Productos. Sigue el mismo proceso que antes. Ejecuta los siguientes comandos para compilar un contenedor de Docker, implementa tu contenedor y expónlo mediante un servicio de Kubernetes.

1. Crea un contenedor de Docker con Cloud Build:

cd ~/monolith-to-microservices/microservices/src/products gcloud builds submit --tag gcr.io/${GOOGLE_CLOUD_PROJECT}/products:1.0.0 .

2. Implementa el contenedor en GKE:

kubectl create deployment products --image=gcr.io/${GOOGLE_CLOUD_PROJECT}/products:1.0.0

3. Expone el contenedor de GKE:

kubectl expose deployment products --type=LoadBalancer --port 80 --target-port 8082

4. Busca la IP pública del servicio Productos de la misma manera que lo hiciste con el servicio Pedidos:

kubectl get service products

Resultado:

NAME CLUSTER-IP EXTERNAL-IP PORT(S) AGE products 10.3.251.122 203.0.113.0 80:30877/TCP 3d

Usarás la dirección IP en el próximo paso cuando reconfigures la aplicación monolítica para que apunte a tu nuevo microservicio Productos.

Reconfigura la aplicación monolítica

1. Usa el editor nano para reemplazar la URL local por la dirección IP del nuevo microservicio Productos:

cd ~/monolith-to-microservices/react-app nano .env.monolith

Cuando se abra el editor, tu archivo debería verse de esta forma:

REACT_APP_ORDERS_URL=http://<ORDERS_IP_ADDRESS>/api/orders REACT_APP_PRODUCTS_URL=/service/products

2. Reemplaza REACT_APP_PRODUCTS_URL por el formato nuevo y, a la vez, reemplaza por la dirección IP de tu microservicio Productos para que coincida con lo que se muestra a continuación:

REACT_APP_ORDERS_URL=http://<ORDERS_IP_ADDRESS>/api/orders REACT_APP_PRODUCTS_URL=http://<PRODUCTS_IP_ADDRESS>/api/products

3. Presiona CTRL + O, luego INTRO y, por último, CTRL + X para guardar el archivo.

4. Navega por la URL que acabas de establecer en el archivo para probar el microservicio nuevo. La página web debería mostrar una respuesta JSON de tu microservicio Productos.

5. Luego, vuelve a compilar el frontend de la aplicación monolítica y repite el proceso de compilación del contenedor en la aplicación y vuelve a implementarlo en el clúster de GKE. Ejecuta los siguientes comandos para completar estos pasos:

6. Compila nuevamente los archivos de configuración de la aplicación monolítica:

npm run build:monolith

7. Crea un contenedor de Docker con Cloud Build:

cd ~/monolith-to-microservices/monolith gcloud builds submit --tag gcr.io/${GOOGLE_CLOUD_PROJECT}/monolith:3.0.0 .

8. Implementa el contenedor en GKE:

kubectl set image deployment/monolith monolith=gcr.io/${GOOGLE_CLOUD_PROJECT}/monolith:3.0.0

9. Verifica que tu aplicación responda al nuevo microservicio Productos. Para ello, desde tu navegador, ve a la aplicación monolítica y navega a la página de Productos. Todos los nombres de los productos deberían comenzar con el prefijo MS- como se muestra a continuación:

10. Haz clic en Revisar mi progreso para verificar el objetivo. Migra Productos a un microservicio

Tarea 6. Migra Frontend a un microservicio

El último paso del proceso de migración consiste en mover el código Frontend a un microservicio y cerrar la aplicación monolítica. Cuando se complete este paso, habremos migrado con éxito nuestra aplicación monolítica a una arquitectura de microservicios.

Crea un nuevo microservicio frontend

Sigue el mismo procedimiento que en los últimos dos pasos para crear un nuevo microservicio Frontend.

Anteriormente, cuando compilaste nuevamente la aplicación monolítica, actualizaste la configuración para que apunte a ella. Ahora, debes usar la misma configuración para el microservicio Frontend.

1. Ejecuta los siguientes comandos para copiar los archivos de configuración de la URL de los microservicios en la base de código del microservicio Frontend:

cd ~/monolith-to-microservices/react-app cp .env.monolith .env npm run build

2. Cuando se complete la ejecución de los comandos, sigue el mismo proceso que en los pasos anteriores. Ejecuta los siguientes comandos para compilar un contenedor de Docker, implementa tu contenedor y expónlo mediante un servicio de Kubernetes.

3. Crea un contenedor de Docker con Google Cloud Build:

cd ~/monolith-to-microservices/microservices/src/frontend gcloud builds submit --tag gcr.io/${GOOGLE_CLOUD_PROJECT}/frontend:1.0.0 .

4. Implementa el contenedor en GKE:

kubectl create deployment frontend --image=gcr.io/${GOOGLE_CLOUD_PROJECT}/frontend:1.0.0

5. Expone el contenedor de GKE

kubectl expose deployment frontend --type=LoadBalancer --port 80 --target-port 8080

6. Haz clic en Revisar mi progreso para verificar el objetivo. Migra Frontend a un microservicio

Borra la aplicación monolítica

Ahora que todos los servicios se ejecutan como microservicios, puedes borrar la aplicación monolítica. Ten en cuenta que, en una migración real, esto implicaría también cambios de DNS, entre otros, para lograr que nuestros nombres de dominio apunten a los microservicios nuevos Frontend de nuestra aplicación.

• Ejecuta los siguientes comandos para borrar la aplicación monolítica:

kubectl delete deployment monolith kubectl delete service monolith

Prueba tu trabajo

Para verificar que todo está en funcionamiento, la dirección IP anterior de tu servicio de aplicación monolítica no debería funcionar ahora, y la nueva dirección IP de tu servicio Frontend debería alojar la nueva aplicación.

• Para ver una lista de todos los servicios y las direcciones IP, ejecuta el siguiente comando:

kubectl get services

El resultado debería ser similar al siguiente:

NAME TYPE CLUSTER-IP EXTERNAL-IP PORT(S) AGE frontend LoadBalancer 10.39.246.135 35.227.21.154 80:32663/TCP 12m kubernetes ClusterIP 10.39.240.1 443/TCP 18d orders LoadBalancer 10.39.243.42 35.243.173.255 80:32714/TCP 31m products LoadBalancer 10.39.250.16 35.243.180.23 80:32335/TCP 21m

Cuando hayas determinado la dirección IP externa para tu microservicio Frontend, cópiala y escribe esta URL (como http://203.0.113.0) en tu navegador para verificar si se puede acceder a tu Frontend. Tu sitio web debería verse de la misma forma que se veía antes del desglose de la aplicación monolítica en microservicios.

¡Felicitaciones!

Desglosaste tu aplicación monolítica en microservicios y los implementaste en Google Kubernetes Engine con éxito.

Finaliza la Quest

Este lab de autoaprendizaje forma parte de la Quest Website on Google Cloud. Una Quest es una serie de labs relacionados que forman una ruta de aprendizaje. Inscríbete en esta Quest y obtén un crédito inmediato de finalización si realizaste este lab. Consulta el catálogo de Google Cloud Skills Boost para ver otras Quests disponibles.

¿Estás buscando un Lab de desafío práctico para demostrar tus habilidades y validar tu conocimiento? Cuando completes esta Quest, finaliza este Lab de desafío adicional.

Realiza tu próximo lab

Continúa aprendiendo con este video sobre un caso de éxito Hosting Scalable Web Apps on Google Cloud o bien revisa estas sugerencias:

• Cómo alojar una aplicación web en Google Cloud mediante Compute Engine
• Mira el video Hosting a Static Web App on Google Cloud

Próximos pasos/Recursos adicionales

• [Documentación de Docker]https://docs.docker.com/
• Documentación de Kubernetes
• Documentación de Google Kubernetes Engine (GKE)
• Documentación de Google Cloud Build
• Documentación de Google Container Registry
• Migrar de aplicaciones monolíticas a microservicios
• Prácticas recomendadas de microservicios

Capacitación y certificación de Google Cloud

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

Actualización más reciente del manual: 20 de septiembre de 2023

Prueba más reciente del lab: 20 de septiembre de 2023

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