Migra configuraciones a Cloud Run

Debes completar el proceso de migración de configuración para cada aplicación de Cloud Foundry que migres a Cloud Run. La migración de configuración consta de lo siguiente:

Convertir manifest.yaml de Cloud Foundry en service.yaml de Cloud Run.
Adjuntar cualquier servicio de respaldo a la aplicación para su implementación en Cloud Run.
Implementar la aplicación en un servicio de Cloud Run.

Convierte `manifest.yaml` en `service.yaml`

Debes convertir un manifiesto de Cloud Foundry o las marcas de la CLI de cf en el YAML de definición de servicio de Cloud Run equivalente.

Cloud Run requiere que cada aplicación tenga su propio archivo YAML de servicio independiente. Para migrar una aplicación en tu manifiesto de Cloud Foundry a un archivo YAML de servicio, haz lo siguiente:

Recopila las propiedades que se enumeran en la siguiente tabla para tu aplicación. Las configuraciones globales de la plataforma de Cloud Foundry podrían haber anulado las propiedades que no se modificaron a nivel de la aplicación. Consulta la documentación que proporcionan los administradores de tu plataforma para obtener los valores reales.

Propiedad de la aplicación	Marcas de la CLI v6 de `cf`	Descripción
`name`	Argumento `NAME`	El nombre único de la aplicación en Cloud Foundry
`command`	`-c`	Un comando que se ejecutará en `/bin/sh` o `/bin/bash`
`disk_quota`	`-k`	La cantidad de disco que se asignará a la aplicación. Las unidades válidas son: `M`, `MB`, `G`, `r B` Probable de forma predeterminada: 1 G
`docker.image`	`--docker-image`, `-o`	La imagen que contiene la aplicación que se ejecutará.
`health-check-http-endpoint`	N/A	El extremo que se usa para determinar el estado de HTTP si el tipo de verificación de estado es HTTP. Configuración predeterminada: `/`
`health-check-invocation-timeout`	N/A	Tiempo en segundos entre el puerto individual y las verificaciones de estado basadas en HTTP. Configuración predeterminada: 1
`health-check-type`	`--health-check-type`, `-u`	Tipo de verificación de estado que se realiza en la aplicación. Los valores válidos son: `port`, `http`, `none`, `process`. Configuración predeterminada: `port`
`instances`	`-i`	Cantidad de instancias de la app que ejecutará Cloud Foundry. Configuración predeterminada: 1
`memory`	`-m`	El límite de memoria por instancia para la aplicación. Las unidades válidas son: `M`, `MB`, `G` o `GB` Probable de forma predeterminada: 1 G
`timeout`	`-t`	Cantidad de segundos permitidos entre el inicio de la app y la primera verificación de estado en buen estado. Probable de forma predeterminada: 60

Recopila la siguiente información para tu proyecto de Google Cloud y la configuración de Cloud Run:

Propiedad	Descripción
`project_number`	El número de proyecto del proyecto de Google Cloud en el que deseas realizar la implementación.
`region`	La región en la que deseas implementar tu app.
`vpc-access-connector`	El nombre del conector de VPC en el que el administrador de tu plataforma desea aplicaciones.
`vpc-access-egress`	El nombre de la salida de VPC en el que el administrador de la plataforma desea aplicaciones.
`custom-audiences`	Públicos personalizados que pueden autenticarse en tu aplicación.
`serviceAccountName`	La identidad con la que actuará tu aplicación en Google Cloud.
`image`	La imagen de la aplicación que generaste en el paso anterior.

Propaga la siguiente plantilla en un archivo service.yaml en la raíz de tu proyecto

apiVersion: serving.knative.dev/v1
kind: Service
metadata:
  # Set this to be the name of your app
  name: "APP_NAME"
  # Set this to be the project number of the project you're deploying to.
  namespace: "PROJECT_NUMBER"
  labels:
    # Set this to be the region you're deploying in.
    cloud.googleapis.com/location: REGION
    migrated-from: cloud-foundry
  annotations:
    run.googleapis.com/ingress: internal-and-cloud-load-balancing
spec:
  template:
    metadata:
      annotations:
        # Set to the greater of 1 or the `instances` attribute.
        autoscaling.knative.dev/minScale: '1'
        # Set to the greater of 1 or the `instances` attribute.
        autoscaling.knative.dev/maxScale: '1'
        run.googleapis.com/cpu-throttling: CPU_ALLOCATION
        run.googleapis.com/startup-cpu-boost: 'true'
        # Set to true if you rely on sticky sessions. These will be turned
        # on in Cloud Foundry if the server sends a JSESSIONID cookie back
        # on responses.
        run.googleapis.com/sessionAffinity: 'false'
        run.googleapis.com/execution-environment: gen2
        # Set the following values to match what your platform administrator recommends.
        run.googleapis.com/vpc-access-connector: ADMINISTRATOR_PROVIDED
        run.googleapis.com/vpc-access-egress: ADMINISTRATOR_PROVIDED
        run.googleapis.com/custom-audiences: ADMINISTRATOR_PROVIDED
    spec:
      # CF doesn't limit, but CR has a max of 1000.
      containerConcurrency: 1000
      # Default value for gorouter in PCF.
      timeoutSeconds: 900
      # Set the following value to match what your platform administrator recommends.
      serviceAccountName: ADMINISTRATOR_PROVIDED
      containers:
      - name: user-container
        # Set the following value to either:
        # - The image you built for your application in the last section of the guide.
        # - The docker.image attribute of your app's configuration if it's a Docker app.
        image: IMAGE
        # Set `command` based on the following rules:
        # - If your app has no `command` attribute: null.
        # - If your app has a docker.image attribute: ['/bin/sh', '-c']
        # - Otherwise: ['/bin/bash', '-c']
        command: null
        # Set `args` based on the following rules:
        # - If your app has no `command` attribute: null.
        # - If your app has a `command` attribute: ['value of command']
        args: null
        ports:
          # Set name based on the following rules:
          # - If your app is HTTP/2 or gRPC: "h2c"
          # - Else: "http1"
        - name: HTTP1_OR_H2C
          containerPort: 8080
        env:
          # For each key/value pair in your space's running environment variable groups,
          # which can be retried by running `cf running-environment-variable-group`,
          # add the following:
        - name: KEY
          value: VALUE
          # For each key/value pair in your manifest's `env` map, add the following:
        - name: KEY
          value: VALUE
          # Populate MEMORY_LIMIT with the amount of memory supplied to this instance
          # in MiB with 'M' as a suffix.
        - name: MEMORY_LIMIT
          value: '0M'
          # Set the following values in the JSON below:
          # - `application_name` and `name` to match metadata.name in this file.
          # - `application_uris` and `uris` to be the URI you want to assign the app on the
          #    load balancer.
          # - `limits.disk` to be the amount (in MiB) of disk assigned to your app.
          #   The amount will be in the `disk_quota` attribute of the CF manifest, or a
          #   default value for your cluster, typically 1GiB.
          # - `limits.mem` to be the amount (in MiB) of memory assigned to your app.
          #   The amount will be in your `memory` attribute of the CF manifest, or a
          #   default value for your cluster, typically 1GiB.
          # - `space_name` to be the value of metadata.space in this file.
        - name: VCAP_APPLICATION
          value: |-
                  {
                    "application_id": "00000000-0000-0000-0000-000000000000",
                    "application_name": "app-name",
                    "application_uris": [],
                    "limits": {
                      "disk": 1024,
                      "mem": 256
                    },
                    "name": "app-name",
                    "process_id": "00000000-0000-0000-0000-000000000000",
                    "process_type": "web",
                    "space_name": "none",
                    "uris": []
                  }
        resources:
          limits:
            # Set memory limit to be the sum of the memory and disk assigned to your app in CF.
            # 
            # Disk amount will be in the `disk_quota` attribute of the CF manifest, or a
            # default value for your cluster, typically 1GiB.
            #
            # Memory will be in your `memory` attribute of the CF manifest, or a
            # default value for your cluster, typically 1GiB.
            memory: MEMORY_LIMIT
            # Set cpu according to the following calculation:
            #
            # 1. Take the amount of memory in your `memory` attribute of the CF
            #    manifest, or a default value for your cluster, typically 1GiB.
            # 2. Divide that by the total amount of memory on the underlying BOSH VM.
            # 3. Multiply that by the total number of CPUs on the BOSH VM.
            # 4. Find the nearest valid value based on the rules in:
            #    https://cloud.google.com/run/docs/configuring/cpu#setting
            cpu: CPU_LIMIT
        # If `health-check-type` is "process" or "none", delete the startupProbe section.
        startupProbe:
          # If `health-check-type` is "port" or blank, delete the httpGet section.
          httpGet:
            # Set to be the value of `health-check-http-endpoint` or / if blank.
            path: CHECK_PATH
            port: 8080
          # If `health-check-type` is "http", delete the tcpSocket section.
          tcpSocket:
            port: 8080
          # Set to the value of `health-check-invocation-timeout` or 1
          timeoutSeconds: 1
          # Set failure threshold to be the following calculation:
          #
          # 1. Take the `timeout` from the CF manifest, use 60 if unset.
          # 2. Divide by 2.
          # 3. Round up to the nearest integer.
          failureThreshold: 1
          successThreshold: 1
          periodSeconds: 2
        # If `health-check-type` is "process" or "none", delete the livenessProbe section.
        livenessProbe:
          # If `health-check-type` is "port" or blank, delete the httpGet section.
          httpGet:
            # Set to be the value of `health-check-http-endpoint` or / if blank.
            path: CHECK_PATH
            port: 8080
          # If `health-check-type` is "http", delete the tcpSocket section.
          tcpSocket:
            port: 8080
          # Set to the value of `health-check-invocation-timeout` or 1.
          timeoutSeconds: 1
          failureThreshold: 1
          successThreshold: 1
          periodSeconds: 30
  traffic:
  - percent: 100
    latestRevision: true

Adjunta cualquier servicio de respaldo

Debes construir una variable de entorno VCAP_SERVICES para permitir la inserción y el descubrimiento de servicios de tu aplicación de Cloud Foundry, como Spring o Meshtoe. Debes hacer esto para cada aplicación que estés migrando. Consulta la documentación de VCAP_SERVICES de Cloud Foundry para obtener más información.

Si tu aplicación ya se ejecuta en Cloud Foundry y deseas conectarte a los mismos servicios en Cloud Run, puedes usar la variable de entorno existente. De lo contrario, deberás crear un VCAP_SERVICES nuevo.

Para configurar la variable de entorno VCAP_SERVICES, haz lo siguiente:

Para un VCAP_SERVICES existente:
1. Intenta obtener la variable de entorno VCAP_SERVICES a través de la ejecución de cf env APP_NAME.
2. Si eso no funciona:
  1. Conéctate a tu aplicación en Cloud Foundry: cf ssh APP_NAME
  2. Ejecuta el comando env y obtén el resultado de VCAP_SERVICES.
  3. Ejecuta exit para salir de la sesión SSH.
3. Guarda el valor VCAP_SERVICES en un archivo nuevo llamado vcap.json.
Si deseas agregar servicios o conectarte a servicios diferentes a los de Cloud Foundry, crea un VCAP_SERVICES nuevo:
1. En un editor de texto, crea un mapa JSON vacío {}.
2. Para cada servicio que desees agregar, haz lo siguiente:
3. Consulta la documentación de la biblioteca que usa tu app para analizar VCAP_SERVICES para el tipo que quieres agregar para comprender cómo descubre la vinculación.
4. Agrega una clave al mapa con el nombre del proveedor de servicios si aún no existe, por lo general, es mysql, postgresql o elasticsearch. Configura el valor para que sea un array vacío:
5. Agrega un objeto al array con las siguientes propiedades:
  1. Metadatos que no se suelen usar para descubrir o vincular servicios:
    - binding_name: es una cadena que representa el recurso que otorga a tu aplicación permisos en el servicio. Puede ser un nombre de usuario para una base de datos, una regla de firewall, un nombre de cuenta de servicio o algo más.
    - instance_name: es una string que representa el nombre del servicio de respaldo. Puede ser el nombre de la base de datos, un valor aleatorio o un valor sentinel para un servicio global.
    - name: es el valor binding_name, si existe; de lo contrario, el instance_name. Este valor no suele ser importante.
    - label: es el valor de la clave en el mapa VCAP_SERVICES en el que se anida esta vinculación.
    - plan: es el nombre del plan de servicio. Algunos ejemplos son: “proporcionado por el usuario”, “alta disponibilidad”.
  2. Valores que se usan con frecuencia para descubrir o vincular servicios:
    - tags: es una lista de etiquetas para ayudar a las bibliotecas a encontrar servicios compatibles. A menudo, esto incluye el nombre común del servicio, p.ej., mysql para MySQL y MariaDB, redis para Redis o Cloud Memorystore, o postgres para bases de datos compatibles con Postgres.
    - credentials: es un objeto que contiene credenciales que usa la biblioteca cliente para realizar la conexión. La mayoría de las bibliotecas cliente se basan en un campo uri que contiene el URI estándar del servicio o el formato JDBC.
6. Guarda el contenido como vcap.json.

Adjunta credenciales a tu recurso de Cloud Run

Para adjuntar credenciales, haz lo siguiente:

Crea un Secret para guardar el contenido de la variable de entorno VCAP_SERVICES y toma nota del resultado de la versión del comando:
```
gcloud secrets create APP_NAME-vcap \
  --replication-policy="automatic" \
  --data-file=vcap.json
```

Otorga permiso a la cuenta de servicio de tu aplicación para leer el Secret:

gcloud secrets add-iam-policy-binding APP_NAME-vcap \
  --member="serviceaccount:app-service-account" \
  --role="roles/secretmanager.secretAccessor"

Agrega la siguiente variable de entorno a tu aplicación service.yaml en el spec.template.spec.containers[0].env array:

- name: VCAP_SERVICES
  valueFrom: 
    secretKeyRef:
      key: Version output by step 1
      name: APP_NAME-vcap

Plantillas para servicios de respaldo comunes

En las siguientes secciones, se proporciona información sobre los servicios de respaldo de uso común.

MySQL

Por lo general, las bibliotecas de MySQL esperan la etiqueta mysql. Es común incluir las siguientes claves en credentials:

Plantilla uri: mysql://username:password@host:port/dbname. La documentación de MySQL puede ayudarte a crear una string de URI. Por lo general, el puerto es 3306.
username: es el nombre de usuario de conexión que requieren algunas bibliotecas, incluso si se incluye en uri
password: es la contraseña de conexión que requieren algunas bibliotecas, incluso si se incluye en uri

Redis

Por lo general, las bibliotecas de Redis esperan la etiqueta redis. Es común incluir las siguientes claves en credentials:

Plantilla uri: redis://:password@host:port/dbunumber.

La documentación del URI de Redis de IANA puede ayudarte a crear una cadena de URI. Por lo general, el puerto es 6379.

RabbitMQ

Por lo general, las bibliotecas de RabbitMQ esperan la etiqueta rabbitmq y las siguientes claves en credentials:

Plantilla uri: amqp://username:password@host:port/vhost?query.

La documentación de RabbitMQ puede ayudarte a crear una cadena de URI. Por lo general, el puerto es 5672.

Servicios proporcionados por el usuario

Los servicios proporcionados por el usuario son un tipo especial de servicio en Cloud Foundry que te permite incorporar cualquier credencial. La etiqueta siempre es user-provided. Las etiquetas son los valores que se pasan a cf create-user-provided-service a través de la marca -t y las credenciales son el contenido de la marca -p.

Implementa tu aplicación

Para implementar la aplicación de Cloud Foundry completamente migrada en un servicio de Cloud Run, haz lo siguiente:

Si aún no lo hiciste, configura tu entorno de Cloud Run.
Ejecuta el comando
```
gcloud run services replace service.yaml
```
Espere un momento a que finalice la implementación. Si la operación es exitosa, la línea de comandos mostrará la URL de servicio.
Abre la URL de servicio en un navegador web para visitar el servicio implementado.

¡Felicitaciones! Acabas de migrar tu aplicación de Cloud Foundry a Cloud Run