Carrera de Google

Google Run ofrece un enfoque de contenedor sin servidores para implementar microservicios sin necesidad de usar Kubernetes, lo que te permite acelerar la publicación de microservicios basados en la plataforma Devprime.

Introducción

La plataforma Devprime acelera la productividad de los desarrolladores de software al ofrecer un diseño completo de arquitectura de software, componentes con comportamientos inteligentes, aceleradores para la implementación de código y actualizaciones con nuevas funciones.

En este artículo, cubriremos el uso de Google Run, una plataforma para contenedores sin servidor basada en la pila de Google Cloud. Al implementar este escenario, se usará un microservicio basado en la plataforma Devprime. Este microservicio estará vinculado a una cuenta activa de Google Cloud, con un proyecto que contiene un Stream basado en Google Pub/Sub, una base de datos en Google Cloud SQL (compatible con MySQL, PostgreSQL y SQL Server), un repositorio en Google Artifact Registry y un nuevo servicio en Google Run.

Durante este artículo, usaremos un microservicio con una regla de negocio relacionada con el orden, y la base de datos PostgreSQL se integrará con una cola creada en Google Pub/Sub. Te guiaremos a través de los pasos para crear el microservicio y, luego, cubriremos la configuración que necesitas para que esté disponible en Google Run.

Ejecución de Google

Lista de verificación y preparación del entorno inicial:

Abra una cuenta en Devprime Platform y compre una licencia Developer/Enterprise).
Instalar una versión actualizada de .NET (Linux, macOS y Windows)
Instalar y/o actualizar Visual Studio Code y/o Visual Studio 2023 Community / Professional / Enterprise.
Instale y/o actualice docker (para Windows, use WSL2).
Instale Powershell o use Bash en Linux
Instale y active la última versión de la Devprime CLI.
Crea una carpeta para tus proyectos y establece permisos de lectura y escritura.
Véase el artículo “Creación del primer microservicio” para explorar cómo empezar a trabajar con la plataforma Devprime.

Lista de verificación de Google Cloud

Una cuenta activa en Google Cloud.
Instala la CLI de Google Cloud.
Inicie sesión a través de Google CLI (gcloud init).
Crea una base de datos PostgreSQL en Google Cloud SQL.
Obtenga la IP y las credenciales de PostgreSQL y libere la red 0.0.0.0/0 para el acceso externo.
Crea un tema “oderevents” en Google Pub/Sub (https://console.cloud.google.com/cloudpubsub).
Cree y obtenga json con credenciales, permisos de acceso para los servicios.
La creación y publicación en Google Artifact Registry y un nuevo servicio en Google Run se realizará mediante script.
Puedes usar un cliente de PostgreSQL localmente para validar el acceso a Google Cloud SQL.

Creación de un nuevo microservicio

Creación del primer microservicio
dp new ms-order --stream googlepubsub --state postgresql
Adición de una regla de negocio de ejemplo
dp marketplace order
Inicialización y aceleración de implementaciones de microservicios
dp init

En este punto, el microservicio destinado a este ejemplo está listo para su uso en producción y es posible ejecutarlo localmente. El siguiente paso es agregar tus credenciales de Google Cloud a tu microservicio.

Adición de credenciales en el microservicio
Este microservicio usará las credenciales para acceder a Google PubSub y Google Cloud SQL y debe introducirse en el archivo de configuración src/App/appsettings.json tal y como se define en el Adaptador de flujo con Google PubSub y Adaptador de estado con PostgreSQL.

Abrir en Visual Studio Code
code src/App/appsettings.json

Localice la configuración del adaptador Ed Stream e incluya las credenciales obtenidas
en JSON

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21


"DevPrime_Stream": [
    {
      "Alias": "Stream1",
      "Enable": "true",
      "Default": "true",
      "StreamType": "GooglePubSub",
      "Project_ID": "",
      "Private_Key_ID": "",
      "Private_Key": "",
      "Client_Email": "",
      "Client_ID": "",
      "Auth_URI": "",
      "Token_URI": "",
      "Auth_Provider_x509_Cert_Url": "",
      "Client_X509_Cert_Url": "",
      "Retry": "3",
      "Fallback": "State1",
      "Threads": "10",
      "Subscribe": []
    }
  ],

Localiza la clave del adaptador de estado e introduce las credenciales de acceso a Google Cloud SQL
como la dirección IP que se debe ingresar en el Host, nombre de usuario y contraseña.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12


"DevPrime_State": [
    {
      "enable": "true",
      "alias": "State1",
      "dbtype": "postgresql",
      "type" : "db",
      "connection": "Host=localhost;Username=postgres;Password=LltF8Nx*yo;Database=ms-order",
      "timeout": "5",
      "retry": "2",
      "durationofbreak": "45"
    }
  ],

Aplicación de la estructura de la base de datos
La base de datos en este escenario es PostgreSQL y, antes de ejecutar el microservicio, es fundamental ejecutar un script para crear las tablas de la base de datos que requiere el microservicio. Puede utilizar la herramienta Devprime CLI para generar los archivos SQL y aplicarlos manualmente o aplicarlos directamente a la base de datos.

Ejecute el comando que se aplicará a la base de datos.
dp state apply state1

Exportación de la configuración para publicar en Google Run
La Devprime CLI proporciona una utilidad para facilitar la creación de una secuencia de comandos para publicar la imagen de docker del microservicio en el repositorio privado de Google Artifact Registry y, luego, crear un nuevo servicio en Google Run.

Ejecute el comando export
dp export googlerun

Después de exportar, se crearán dos archivos (Powershell o Bash) que contienen la secuencia de comandos para ejecutar la publicación en Google Cloud.

Elige el archivo que prefieras y edítalo con Visual Studio Code, cambiando la configuración inicial, como el nombre del proyecto de Google Cloud, el nombre de la aplicación y el repositorio.

Abrir desde Visual Studio Code

code .devprime/google/googlerun.ps1
code .devprime/google/googlerun.sh

Ejecutando el script
Antes de ejecutar la secuencia de desfiles, asegúrate de que docker se esté ejecutando en tu entorno, de que hayas iniciado sesión en él y de que la CLI de Google Cloud esté instalada y activa. El script debe ejecutarse desde el directorio raíz del proyecto.

Ejecute uno de los comandos:

.\.devprime\google\googlerun.ps1 (Windows)
.devprime/google/googlerun.sh (MacOS y Linux)

Reflexiones finales

En este ejemplo, puedes ver lo fácil que es desarrollar un nuevo microservicio utilizando la plataforma Devprime y sus aceleradores, seguido del proceso de publicarlo en Google Cloud en cuestión de segundos.

Reemplace este script con un proceso de DevOps automatizando el procedimiento.
En el entorno de producción, implemente medidas de seguridad como una puerta de enlace de API y una bóveda para el almacenamiento seguro de credenciales.
Adoptar los procedimientos aislando la red para exportar solo los servicios públicos.

Última modificación April 11, 2024 (cc33f7e6)