Desarrollar un servicio de Cloud Run de forma local en Cloud Code para VS Code

Antes de implementar un servicio en Cloud Run, puedes desarrollarlo de forma local con un emulador de Cloud Run.

Configura el servicio para el desarrollo

Si no tienes un archivo .vscode/launch.json definido, el diálogo Run/Debug on Cloud Run Emulator te permite configurar el inicio y, luego, guardar la configuración en .vscode/launch.json. Si tienes un archivo .vscode/launch.json configurado, puedes editarlo directamente.

Para ejecutar el servicio de forma local, especifica la configuración:

Abre la paleta de comandos (presiona Ctrl/Cmd+Shift+P o haz clic en View > Command Palette) y, luego, ejecuta el comando Run on Cloud Run Emulator.

En el diálogo Run/Debug on Cloud Run Emulator, establece las especificaciones para tu configuración:

Solo las herramientas de compilación instaladas de forma local están disponibles para el emulador de Cloud Run
Selecciona Docker o Buildpacks como compilador y, luego, especifica la fuente.

Para especificar las variables de entorno que se pasarán a los contenedores en ejecución, expande Configuración de compilación avanzada y, luego, haz clic para especificar pares clave-valor (opcional).

Nombre	Descripción	Ejemplo
PORT	El puerto para que el servidor HTTP escuche.	8080
K_SERVICE	El nombre del servicio de Cloud Run que se ejecuta.	hello-world
K_REVISION	El nombre de la revisión de Cloud Run que se ejecuta.	hello-world.1
K_CONFIGURATION	El nombre de la configuración de Cloud Run que creó la revisión.	hello-world

Para especificar las conexiones de Cloud SQL, expande la Configuración avanzada del servicio, haz clic en Conexiones y, luego, especifica una conexión de Cloud SQL por línea (opcional).
(Opcional) Marca la opción para hacer que el servicio sea accesible desde otros dispositivos en la red local.
(Opcional) Si solo deseas volver a compilar y ejecutar tu servicio de forma manual, en lugar de hacerlo automáticamente cuando realizas un cambio, desmarca la opción Volver a compilar y ejecutar automáticamente los cambios.

Ejecuta el servicio de forma local

Después de definir la configuración preferida, ejecuta el servicio haciendo clic en Ejecutar.
Supervisa el estado de tu implementación en la ventana de salida.

Una vez finalizada la implementación, puedes ver el servicio en ejecución abriendo la URL que se muestra en la ventana de salida.
Para ver los registros detallados, cambia a la vista detallada de Cloud Run en la ventana de salida.
Cuando finalice su sesión, haga clic con el botón derecho para usar los siguientes comandos:
- View Logs: Abre los registros de la aplicación de una implementación específica con el explorador de registros de Cloud Code.
- Abrir URL: abre la URL del servicio de aplicación de un servicio específico en un navegador web
Para detener la implementación, puedes hacer clic en el botón Stop en la barra de acciones de la implementación actual.

Almacena secretos

Si tu código incluye datos potencialmente sensibles, como claves de API, contraseñas y certificados, su almacenamiento como secretos puede ayudarte a protegerlos. La integración de Secret Manager de Cloud Code te permite almacenar estos secretos de forma segura y recuperarlos de manera programática. Para obtener información detallada sobre cómo crear y administrar secretos con Cloud Code, consulta la guía de Secret Manager.

Personaliza una configuración launch.json existente

El complemento de Cloud Code actualiza el archivo de configuración launch.json automáticamente cuando eliges una acción de ejecución. Para personalizar aún más cómo se ejecuta tu servicio, puedes especificar los siguientes campos en tu archivo .vscode/launch.json:

watch: Observa los cambios en el lugar de trabajo y vuelve a ejecutar el servicio. Verdadero de forma predeterminada.

En el siguiente ejemplo, se muestra el reloj configurado en true:
```
"watch": true,
```
build: especifica el compilador (Docker, JibMaven, jibGradle o buildpacks) para que compile tus imágenes.

En el siguiente ejemplo, se muestra un compilador de Docker:
```
"build": {
  "docker": {
    "path": "Dockerfile"
  }
},
```
En el siguiente ejemplo, se muestra un compilador de paquetes de compilación:
```
"build": {
  "buildpacks": {
    "path": "src/requirements.txt",
    "builder": "gcr.io/buildpacks/builder:v1"
  }
},
```
image: Especifica el nombre de la imagen que se usará.

En el siguiente ejemplo, se muestra cómo especificar un nombre de imagen:
```
  "image": "hello-world",
```
service: Especifica el servicio de Cloud Run que se usará.

En el siguiente ejemplo, se muestra cómo especificar un nombre de servicio, un puerto y límites de recursos:
```
"service": {
  "name": "hello-world",
  "containerPort": 8080,
  "resources": {
    "limits": {
      "memory": "256Mi"
    }
  }
},
```
debug: especifica una configuración de depuración como la asignación de ruta remota para asignar una ruta local a una ruta en el contenedor remoto.

En el siguiente ejemplo, se muestra una sección de depuración que indica los archivos de origen:
```
"debug": {
  "sourceFileMap": {
    "${workspaceFolder}": "/app"
  }
}
```

Habilita la sincronización de archivos de Skaffold y la recarga en caliente

Para mejorar la eficiencia de tu flujo de trabajo de desarrollo local y evitar tener que volver a compilar, implementar y reiniciar tus Pods, Skaffold admite la copia de archivos modificados en un contenedor implementado. Esto significa que, cuando realizas cambios en los archivos de código fuente y estáticos, puedes ver los cambios en cuestión de segundos, lo que genera un ciclo de reacción acelerado.

En el caso de los archivos estáticos (como archivos HTML y CSS), el comportamiento de copia de archivos se denomina sincronización de archivos.

Para los archivos de código fuente, este comportamiento se denomina recarga en caliente y admite los siguientes tipos de archivos:

Go: *.go
Java: *.java, *.kt, *.scala, *.groovy, *.clj
NodeJS: *.js, *.mjs, *.coffee, *.litcoffee, *.json

Con la recarga en caliente configurada, Skaffold detecta cambios en los archivos compatibles y los sincroniza con el contenedor en ejecución del clúster. Los cambios en los tipos de archivo que no admiten la recarga en caliente activan la recompilación de una imagen y el reinicio del Pod.

La sincronización automática de archivos y la recarga en caliente están habilitadas de forma predeterminada cuando trabajas con Buildpacks como tu compilador preferido. Para otros compiladores como Docker, puedes especificar una sección sync en tu archivo skaffold.yaml para el artefacto que personalizas.

La configuración de sincronización puede ser una de las siguientes opciones (en orden de preferencia):

auto (solo para artefactos de Jib y Buildpacks) Este es el valor predeterminado si no se especifica para Buildpacks).
infer
manual

En la siguiente sección sync de ejemplo de un archivo skaffold.yaml, se especifica una sincronización manual para sincronizar todos los archivos HTML /static-html con la carpeta static en un contenedor:

build:
  artifacts:
    - image: gcr.io/k8s-skaffold/node-example
      context: node
      sync:
        manual:
          - src: 'static-html/*.html'
            dest: static

Para obtener una descripción detallada de la sincronización de archivos y especificar reglas de sincronización, consulta la guía de Skaffold sobre la sincronización de archivos.

Obtener asistencia

Para enviar comentarios, informa problemas en GitHub o haz preguntas en Stack Overflow.