Implementar una aplicación de flujo de trabajo transaccional de ejemplo en una arquitectura de microservicios en Google Cloud

Clona el código fuente

En esta sección, configurarás tu ID del proyecto y clonarás el código fuente en Cloud Shell.

1. En Cloud Shell, establece tu ID del proyecto:

   PROJECT_ID=PROJECT_ID
   

   Reemplaza PROJECT_ID por el ID del proyecto de Google Cloud que creaste antes.

2. Configure el ID del proyecto:

   gcloud config set project $PROJECT_ID
   

3. Clona el repositorio del instructivo:

   cd $HOME
   git clone https://github.com/GoogleCloudPlatform/transactional-microservice-examples
   

Implementa componentes del servidor para arquitecturas de saga basadas en coreografías

En esta sección, implementarás los componentes del servidor de la aplicación de ejemplo. La aplicación implementa arquitecturas de saga basadas en coreografías, como microservicios en Cloud Run, programas de publicación de eventos en Cloud Scheduler y temas de Pub/Sub.

Compila e implementa imágenes de contenedor

1. En Cloud Shell, compila una imagen de contenedor para el servicio Order llamado order-async e impleméntala en Cloud Run:

   cd $HOME/transactional-microservice-examples/services/order-async
   gcloud builds submit --tag gcr.io/$PROJECT_ID/order-service-async
   gcloud run deploy order-service-async \
     --image gcr.io/$PROJECT_ID/order-service-async \
     --platform=managed --region=us-central1 \
     --no-allow-unauthenticated
   

2. Compila una imagen de contenedor para el servicio Customer llamado customer-async e impleméntala en Cloud Run:

   cd $HOME/transactional-microservice-examples/services/customer-async
   gcloud builds submit --tag gcr.io/$PROJECT_ID/customer-service-async
   gcloud run deploy customer-service-async \
     --image gcr.io/$PROJECT_ID/customer-service-async \
     --platform=managed --region=us-central1 \
     --no-allow-unauthenticated
   

3. Compila una imagen de contenedor para el servicio event-publisher y, luego, impleméntala en Cloud Run:

   cd $HOME/transactional-microservice-examples/services/event-publisher
   gcloud builds submit --tag gcr.io/$PROJECT_ID/event-publisher
   gcloud run deploy event-publisher \
     --image gcr.io/$PROJECT_ID/event-publisher \
     --platform=managed --region=us-central1 \
     --no-allow-unauthenticated \
     --set-env-vars "PROJECT_ID=$PROJECT_ID"
   

Crea un índice para Datastore

En esta sección, crearás un índice para Datastore. El servicio event-publisher usa este índice para seleccionar los eventos que se deben publicar.

1. En la consola de Google Cloud, en el menú Datastore, selecciona Modo de Datastore.

2. Haz clic en Elegir dónde almacenar tus datos y selecciona us-east1 como la ubicación. Luego, haz clic en Crear base de datos.

3. Crea un índice para Datastore:

   cd $HOME/transactional-microservice-examples/services/event-publisher
   gcloud datastore indexes create index.yaml --quiet
   

4. En la consola de Google Cloud, en el menú Datastore, selecciona Índices y espera a que el estado del índice cambie de Indexación a Activo. Este proceso puede tardar unos minutos.

Crea una cuenta de servicio para invocar microservicios en Cloud Run

• En Cloud Shell, crea la cuenta de servicio cloud-run-invoker:

  SERVICE_ACCOUNT_NAME="cloud-run-invoker"
  SERVICE_ACCOUNT_EMAIL=${SERVICE_ACCOUNT_NAME}@${PROJECT_ID}.iam.gserviceaccount.com
  gcloud iam service-accounts create $SERVICE_ACCOUNT_NAME \
    --display-name "Cloud Run Invoker"
  

  Usa esta cuenta de servicio más adelante en este instructivo a fin de invocar las APIs de REST para los microservicios que se ejecutan en Cloud Run.

Define una programación para llamar al servicio de publicador de eventos

En esta sección, debes definir un programa para invocar al publicador de eventos llamado event-publisher en intervalos de un minuto.

1. En Cloud Shell, asigna el rol run.invoker al servicio event publisher.

   SERVICE_NAME="event-publisher"
   gcloud run services add-iam-policy-binding $SERVICE_NAME \
     --member=serviceAccount:$SERVICE_ACCOUNT_EMAIL \
     --role=roles/run.invoker \
     --platform=managed --region=us-central1
   

2. Define una programación para llamar al servicio Event publisher llamado event-publisher en intervalos de un minuto mediante la cuenta de servicio cloud-run-invoker:

   SERVICE_NAME="event-publisher"
   SERVICE_URL=$(gcloud run services list --platform managed \
     --format="table[no-heading](URL)"
     --filter="SERVICE:${SERVICE_NAME}")
   SERVICE_URL="${SERVICE_URL}/api/v1/event/publish"
   gcloud scheduler jobs create http event-publisher-scheduler \
     --schedule='* * * * *' \
     --http-method=GET \
     --uri=$SERVICE_URL \
     --oidc-service-account-email=$SERVICE_ACCOUNT_EMAIL \
     --oidc-token-audience=$SERVICE_URL \
     --location=us-central1
   

Crea temas de Pub/Sub

• En Cloud Shell, crea los siguientes temas de Pub/Sub:

  gcloud pubsub topics create order-service-event
  gcloud pubsub topics create customer-service-event
  

El servicio Order y el servicio event-publisher usan el tema order-service-event para publicar eventos del servicio Order. El tema customer-service-event se usa para publicar eventos desde el servicio Customer.

Define un tema para enviar notificaciones de eventos a los microservicios

En esta sección, debes definir el tema push-subscription para entregar mensajes en temas de Pub/Sub a los microservicios.

1. En Cloud Shell, asigna el rol iam.serviceAccountTokenCreator a la cuenta de servicio de Pub/Sub del proyecto:

   PROJECT_NUMBER=$(gcloud projects describe $PROJECT_ID --format "value(projectNumber)")
   gcloud projects add-iam-policy-binding $PROJECT_ID \
     --member=serviceAccount:service-${PROJECT_NUMBER}@gcp-sa-pubsub.iam.gserviceaccount.com \
     --role=roles/iam.serviceAccountTokenCreator
   

   Este comando permite que la cuenta de servicio cree un token de acceso para invocar microservicios en Cloud Run.

2. Asigna el rol run.invoker al servicio customer-service-async:

   SERVICE_NAME="customer-service-async"
   gcloud run services add-iam-policy-binding $SERVICE_NAME \
     --member=serviceAccount:$SERVICE_ACCOUNT_EMAIL \
     --role=roles/run.invoker \
     --platform=managed --region=us-central1
   

3. Crea un tema push-subscription:

   SERVICE_URL=$(gcloud run services list --platform managed \
     --format="table[no-heading](URL)" --filter="SERVICE:${SERVICE_NAME}")
   SERVICE_URL="${SERVICE_URL}/api/v1/customer/pubsub"
   gcloud pubsub subscriptions create push-order-to-customer \
     --topic order-service-event \
     --push-endpoint=$SERVICE_URL \
     --push-auth-service-account=$SERVICE_ACCOUNT_EMAIL
   

   Este tema entrega mensajes en el tema order-service-event al servicio Customer mediante la cuenta de servicio cloud-run-invoker.

4. Asigna el rol run.invoker al servicio order-service-async:

   SERVICE_NAME="order-service-async"
   gcloud run services add-iam-policy-binding $SERVICE_NAME \
     --member=serviceAccount:$SERVICE_ACCOUNT_EMAIL \
     --role=roles/run.invoker \
     --platform=managed --region=us-central1
   

5. Crea un tema push-subscription:

   SERVICE_URL=$(gcloud run services list --platform managed \
     --format="table[no-heading](URL)" --filter="SERVICE:${SERVICE_NAME}")
   SERVICE_URL="${SERVICE_URL}/api/v1/order/pubsub"
   gcloud pubsub subscriptions create push-customer-to-order \
     --topic customer-service-event \
     --push-endpoint=$SERVICE_URL \
     --push-auth-service-account=$SERVICE_ACCOUNT_EMAIL
   

   El tema push-subscription entrega mensajes en el tema customer-service-event al servicio Order mediante la cuenta de servicio cloud-run-invoker.

Implementar componentes del servidor para una arquitectura de organización síncrona

En esta sección, implementarás los componentes del servidor para la aplicación de ejemplo. Estos componentes implementan una arquitectura de organización síncrona en Cloud Run, así como un flujo de trabajo que se ejecuta con Workflows.

Compila e implementa imágenes de contenedor

En esta sección, debes compilar imágenes de contenedor para microservicios y, luego, implementarlas en Cloud Run.

1. En Cloud Shell, compila una imagen de contenedor para el servicio Order llamado order-sync y, luego, impleméntala en Cloud Run:

   cd $HOME/transactional-microservice-examples/services/order-sync
   gcloud builds submit --tag gcr.io/$PROJECT_ID/order-service-sync
   gcloud run deploy order-service-sync \
     --image gcr.io/$PROJECT_ID/order-service-sync \
     --platform=managed --region=us-central1 \
     --no-allow-unauthenticated
   

2. Compila una imagen de contenedor para el servicio Customer llamado customer-sync y, luego, impleméntala en Cloud Run:

   cd $HOME/transactional-microservice-examples/services/customer-sync
   gcloud builds submit --tag gcr.io/$PROJECT_ID/customer-service-sync
   gcloud run deploy customer-service-sync \
     --image gcr.io/$PROJECT_ID/customer-service-sync \
     --platform=managed --region=us-central1 \
     --no-allow-unauthenticated
   

3. Compila una imagen de contenedor para el servicio de procesador Order llamado order-processor y, luego, impleméntala en Cloud Run:

   cd $HOME/transactional-microservice-examples/services/order-processor
   gcloud builds submit --tag gcr.io/$PROJECT_ID/order-processor-service
   gcloud run deploy order-processor-service \
     --image gcr.io/$PROJECT_ID/order-processor-service \
     --platform=managed --region=us-central1 \
     --no-allow-unauthenticated \
     --set-env-vars "PROJECT_ID=$PROJECT_ID"
   

Crea una cuenta de servicio para invocar microservicios en Cloud Run

En esta sección, volverás a usar la cuenta de servicio cloud-run-invoker que creaste en Crea una cuenta de servicio para invocar microservicios en Cloud Run.

Implementa un flujo de trabajo para procesar un pedido

1. En Cloud Shell, asigna los roles run.invoker y run.viewer a la cuenta de servicio cloud-run-invoker para el servicio order-service-sync.

   SERVICE_NAME="order-service-sync"
   gcloud run services add-iam-policy-binding $SERVICE_NAME \
     --member=serviceAccount:$SERVICE_ACCOUNT_EMAIL \
     --role=roles/run.invoker \
     --platform=managed --region=us-central1
   gcloud run services add-iam-policy-binding $SERVICE_NAME \
     --member=serviceAccount:$SERVICE_ACCOUNT_EMAIL \
     --role=roles/run.viewer \
     --platform=managed --region=us-central1
   

2. Asigna los roles run.invoker y run.viewer a la cuenta de servicio cloud-run-invoker para el servicio customer-service-sync:

   SERVICE_NAME="customer-service-sync"
   gcloud run services add-iam-policy-binding $SERVICE_NAME \
     --member=serviceAccount:$SERVICE_ACCOUNT_EMAIL \
     --role=roles/run.invoker \
     --platform=managed --region=us-central1
   gcloud run services add-iam-policy-binding $SERVICE_NAME \
     --member=serviceAccount:$SERVICE_ACCOUNT_EMAIL \
     --role=roles/run.viewer \
     --platform=managed --region=us-central1
   

3. Usa la cuenta de servicio cloud-run-invoker para implementar un flujo de trabajo:

   SERVICE_NAME="order-service-sync"
   ORDER_SERVICE_URL=$(gcloud run services list --platform managed \
     --format="table[no-heading](URL)" --filter="SERVICE:${SERVICE_NAME}")
   
   SERVICE_NAME="customer-service-sync"
   CUSTOMER_SERVICE_URL=$(gcloud run services list --platform managed \
     --format="table[no-heading](URL)" --filter="SERVICE:${SERVICE_NAME}")
   
   cd $HOME/transactional-microservice-examples/services/order-processor
   cp order_workflow.yaml.template order_workflow.yaml
   sed -i "s#ORDER-SERVICE-URL#${ORDER_SERVICE_URL}#" order_workflow.yaml
   sed -i "s#CUSTOMER-SERVICE-URL#${CUSTOMER_SERVICE_URL}#" order_workflow.yaml
   
   gcloud beta workflows deploy order_workflow \
     --source=order_workflow.yaml \
     --service-account=$SERVICE_ACCOUNT_EMAIL
   

Prueba los componentes de la arquitectura de saga basada en coreografías

En esta sección, debes probar los componentes implementados en la arquitectura de saga basada en coreografías con el comando curl.

• En Cloud Shell, configura las variables de entorno que apunten a las URL de los extremos de la API para los microservicios customer-service-async y order-service-async:

  SERVICE_NAME="customer-service-async"
  CUSTOMER_SERVICE_URL=$(gcloud run services list --platform managed \
    --format="table[no-heading](URL)" --filter="SERVICE:${SERVICE_NAME}")
  
  SERVICE_NAME="order-service-async"
  ORDER_SERVICE_URL=$(gcloud run services list --platform managed \
    --format="table[no-heading](URL)" --filter="SERVICE:${SERVICE_NAME}")
  

Crea una entrada de cliente

• En Cloud Shell, crea un ID de cliente llamado customer01 mediante el envío de una solicitud a la API al servicio Customer llamado customer-service-async:

  curl -X POST -H "Authorization: Bearer $(gcloud auth print-identity-token)" \
    -H "Content-Type: application/json" \
    -d '{"customer_id":"customer01", "limit":10000}' \
    -s ${CUSTOMER_SERVICE_URL}/api/v1/customer/limit | jq .
  

  El resultado es similar a este:

  {
    "credit": 0,
    "customer_id": "customer01",
    "limit": 10000
  }
  

Envía un pedido

En esta sección, enviarás un pedido y activarás una asignación de ID de pedido para él.

1. En Cloud Shell, envía un pedido mediante el envío de una solicitud a la API al servicio Order llamado order-service-async:

   curl -X POST -H "Authorization: Bearer $(gcloud auth print-identity-token)" \
     -H "Content-Type: application/json" \
     -d '{"customer_id":"customer01", "number":10}' \
     -s ${ORDER_SERVICE_URL}/api/v1/order/create | jq .
   

   En este caso, debes pedir 10 artículos. Para ello, especifica lo siguiente: "number": 10

   El resultado es similar a este:

   {
     "customer_id": "customer01",
     "number": 10,
     "order_id": "720d1305-b6fd-4f57-aaf4-fd2ca5bdfe1e",
     "status": "pending"
   }
   

   La marca "order_id" del resultado muestra el ID de pedido único que se asigna al pedido. Copia este ID porque lo usarás en el paso siguiente.

2. Establece el ID de pedido en una variable de entorno:

   ORDER_ID=ORDER_ID
   

   Reemplaza ORDER_ID por la marca "order_id" que copiaste en el paso anterior.

Verifica el estado de un pedido

En esta sección, debes verificar cómo cambia el estado de un pedido.

1. En Cloud Shell, obtén el estado del pedido mediante el envío de una solicitud a la API al servicio Order llamado order-service-async:

   curl -X POST -H "Authorization: Bearer $(gcloud auth print-identity-token)" \
     -H "Content-Type: application/json" \
     -d "{\"customer_id\":\"customer01\", \"order_id\":\"$ORDER_ID\"}" \
     -s ${ORDER_SERVICE_URL}/api/v1/order/get | jq .
   

   El resultado se ve de la manera siguiente:

   {
     "customer_id": "customer01",
     "number": 10,
     "order_id": "720d1305-b6fd-4f57-aaf4-fd2ca5bdfe1e",
     "status": "pending"
   }
   

   La marca "status" en el resultado muestra el estado del pedido. Si el proceso transaccional aún se está ejecutando, el estado es "pending". En ese caso, espera unos minutos y vuelve a ejecutar el mismo comando para verificar el estado. Cuando se completa el proceso transaccional, el estado es "accepted".

2. Obtén información del cliente para el ID de cliente customer01:

   curl -X POST -H "Authorization: Bearer $(gcloud auth print-identity-token)" \
     -H "Content-Type: application/json" \
     -d '{"customer_id":"customer01"}' \
     -s ${CUSTOMER_SERVICE_URL}/api/v1/customer/get | jq .
   

   El resultado se ve de la manera siguiente:

   {
     "credit": 1000,
     "customer_id": "customer01",
     "limit": 10000
   }
   

   La marca "credit" muestra el uso de crédito actual del cliente. Aumenta en 1,000 porque la lógica empresarial de esta transacción es aumentar el crédito en 100 por un artículo.

   Puedes repetir el proceso de pedido si repites los pasos que se indican en Envía un pedido. Si pides 100 artículos mediante la especificación de "number": 100, el estado final del pedido es "rejected" porque el uso de crédito supera el límite.

Prueba los componentes de la arquitectura de organización síncrona

En esta sección, probarás los componentes implementados de la arquitectura de organización síncrona mediante el comando curl.

• En Cloud Shell, configura las variables de entorno que apuntan a las URL de los extremos de la API de los microservicios customer-service-sync, order-service-sync y order-processor-service:

  SERVICE_NAME="customer-service-sync"
  CUSTOMER_SERVICE_URL=$(gcloud run services list --platform managed \
    --format="table[no-heading](URL)" --filter="SERVICE:${SERVICE_NAME}")
  
  SERVICE_NAME="order-service-sync"
  ORDER_SERVICE_URL=$(gcloud run services list --platform managed \
    --format="table[no-heading](URL)" --filter="SERVICE:${SERVICE_NAME}")
  
  SERVICE_NAME="order-processor-service"
  ORDER_PROCESSOR_URL=$(gcloud run services list --platform managed \
    --format="table[no-heading](URL)" --filter="SERVICE:${SERVICE_NAME}")
  

Crea una entrada de cliente

• En Cloud Shell, envía una solicitud a la API al servicio Customer llamado customer-service-sync para crear un ID de cliente llamado customer02:

  curl -X POST -H "Authorization: Bearer $(gcloud auth print-identity-token)" \
    -H "Content-Type: application/json" \
    -d '{"customer_id":"customer02", "limit":10000}' \
    -s ${CUSTOMER_SERVICE_URL}/api/v1/customer/limit | jq .
  

  El resultado se ve de la manera siguiente:

  {
    "credit": 0,
    "customer_id": "customer02",
    "limit": 10000
  }
  

Envía un pedido

En esta sección, enviarás un pedido y verificarás el resultado.

1. En Cloud Shell, envía un pedido mediante el envío de una solicitud a la API al servicio Order llamado order-processor-service:

   curl -X POST -H "Authorization: Bearer $(gcloud auth print-identity-token)" \
     -H "Content-Type: application/json" \
     -d '{"customer_id":"customer02", "number":10}' \
     -s ${ORDER_PROCESSOR_URL}/api/v1/order/process | jq .
   

   En este caso, pides 10 artículos mediante la especificación de "number": 10.

   El resultado es similar a este:

   {
     "customer_id": "customer02",
     "number": 10,
     "order_id": "fb6d5087-dd99-4d5a-84c2-0e381016b9d3",
     "status": "accepted"
   }
   

   Debido a que el flujo de trabajo transaccional se realiza de forma síncrona, el cliente ve el resultado de inmediato. En este caso, el estado final es el siguiente: "accepted"

2. Obtén la información del cliente con el ID de cliente customer02:

   curl -X POST -H "Authorization: Bearer $(gcloud auth print-identity-token)" \
     -H "Content-Type: application/json" \
     -d '{"customer_id":"customer02"}' \
     -s ${CUSTOMER_SERVICE_URL}/api/v1/customer/get | jq .
   

   El resultado es similar a este:

   {
     "credit": 1000,
     "customer_id": "customer02",
     "limit": 10000
   }
   

   El uso de créditos del cliente aumenta en 1,000. Para repetir el proceso de pedido, repite estos pasos. Si solicitas 100 artículos mediante la especificación del valor "number": 100, el cliente obtiene de inmediato el resultado "rejected" porque el uso del crédito supera el límite.

Opcional: Implementa una aplicación web

En esta sección, como extensión opcional del instructivo, implementarás una aplicación web de ejemplo que ejecute el flujo de trabajo transaccional sobre los microservicios que implementaste en la sección anterior. Usa Firebase Hosting para implementar una aplicación web que interactúe con microservicios de backend que se ejecutan en Cloud Run.

Firebase Hosting tiene incorporada la integración en Cloud Run, que te permite alojar la aplicación web y los servicios de microservicios de backend en el mismo dominio. En otros tipos de implementación, es posible que tengas problemas de uso compartido de recursos entre dominios (CORS). Si deseas obtener más información, consulta Cómo autenticar usuarios finales.

La integración de Firebase Hosting realiza las siguientes acciones:

• Aloja elementos estáticos en la aplicación web.
• Redirecciona el acceso a las API para los siguientes servicios de backend en Cloud Run:
  • De /customer-service-sync/* a customer-service-sync
  • De /customer-service-async/* a customer-service-async
  • De /order-service-sync/* a order-service-sync
  • De /order-service-async/* a order-service-async
  • De /order-processor-service/* a order-processor-service
• Muestra los elementos estáticos de la aplicación web.

Configura Firebase

En esta sección, configurarás Firebase para alojar la aplicación web en Firebase Hosting.

1. En Cloud Shell, actualiza Node.js a la versión más reciente de LTS para usar Firebase CLI:

   nvm install lts/gallium
   

2. Agregar recursos de Firebase a un proyecto de Google Cloud existente:

   firebase projects:addfirebase $PROJECT_ID
   

3. Agrega un alias de proyecto predeterminado para Firebase CLI:

   jq -n --arg project_id $PROJECT_ID \
     '{"projects": {"default":$project_id}}' > \
     $HOME/transactional-microservice-examples/frontend/.firebaserc
   

Implementa la aplicación web

En esta sección, implementarás la aplicación web en Firebase Hosting.

1. En Cloud Shell, compila la aplicación de frontend web:

   cd $HOME/transactional-microservice-examples/frontend
   yarn install && yarn build
   

2. Implementa la aplicación web en Firebase Hosting:

   firebase deploy
   

Usa la aplicación web

• Ingresa la URL de hosting que copiaste en la sección anterior en tu navegador. Verás la página principal de la aplicación web.

Inicializa la aplicación web con un token de identidad

En esta sección, inicializarás la aplicación web con el token de identidad y pasarás a la página Shopping.

1. En Cloud Shell, imprime el token de identidad:

   gcloud auth print-identity-token
   

2. Copia el resultado del comando anterior y pégalo en el cuadro de texto.

3. Haz clic en Continuar. Se te redireccionará a la página Shopping si el token de identidad es válido.

Agrega artículos a un carrito

• En la aplicación web, haz clic en Agregar al carrito para agregar elementos al carrito.

Revisa los artículos del carrito

• En la aplicación web, haz clic en el ícono de carrito en la barra de navegación para ir a la página Confirmación de la compra. Verás artículos en el carrito.

Envía un pedido con el servicio asíncrono

1. En la aplicación web, haz clic en el ícono de carrito de compras en la barra de navegación para ir a la página Confirmación de la compra.
2. Haz clic en Enviar pedido (asíncrono). Si el pedido se envió correctamente, se te redireccionará a la página Historial de pedidos.

Envía un pedido mediante el servicio síncrono

1. En la aplicación web, haz clic en el ícono de carrito de compras en la barra de navegación para ir a la página Confirmar.
2. Haz clic en Enviar pedido (síncrono). Si el pedido se envió correctamente, se te redireccionará a la página Historial de pedidos.

Verifica el historial de pedidos

• En la aplicación web, haz clic en Pedidos en la barra de navegación para ir a la página Historial de pedidos.

Actualiza el estado de un pedido incompleto

1. En la aplicación web, haz clic en Pedidos en la barra de navegación para ir a la página Historial de pedidos.
2. Haz clic en el ícono de actualización para un pedido individual. El ícono se muestra solo si el pedido se procesa de forma asíncrona y el estado es pending.

Verifica el presupuesto actual de un cliente

• En la aplicación web, haz clic en el nombre del cliente (customer-number) en la barra de navegación para ir a su página de perfil.

Restablece el estado en la aplicación web

• En tu navegador, vuelve a cargar la aplicación web. Se restablecen los estados, como los artículos del carrito, el historial de pedidos y la información del cliente, y se te redirecciona a la página principal.