Esta página foi traduzida pela API Cloud Translation.

Migre configurações do Cloud Foundry para o Cloud Run

Tem de concluir o processo de migração da configuração para cada aplicação do Cloud Foundry que está a migrar para o Cloud Run. A migração da configuração consiste no seguinte:

Converter um manifest.yamlCloud Foundryservice.yaml num service.yamlCloud Runservice.yaml.
Anexar quaisquer serviços de apoio à aplicação para implementação no Cloud Run.
Implementar a sua aplicação num serviço do Cloud Run.

Converter `manifest.yaml` em `service.yaml`

Tem de converter um manifesto do Cloud Foundry e/ou flags da CLI cf no YAML de definição do serviço do Cloud Run equivalente.

O Cloud Run requer que cada aplicação tenha o seu próprio ficheiro YAML de serviço separado. Para migrar uma aplicação no manifesto do Cloud Foundry para um ficheiro YAML de serviço:

Reúna as propriedades indicadas na tabela seguinte para a sua aplicação. As propriedades que não são modificadas ao nível da aplicação podem ter sido substituídas por configurações globais da plataforma Cloud Foundry. Consulte a documentação fornecida pelos administradores da plataforma para obter os valores reais.

Propriedade da aplicação	`cf` Flags da CLI v6	Descrição
`name`	`NAME` argumento	O nome exclusivo da aplicação no Cloud Foundry.
`command`	`-c`	Um comando que vai ser executado em `/bin/sh` ou `/bin/bash`
`disk_quota`	`-k`	A quantidade de disco que vai ser atribuída à aplicação. As unidades válidas são: `M`, `MB`, `G` e `r B` Predefinição provável: 1G
`docker.image`	`--docker-image`, `-o`	A imagem que contém a aplicação a executar.
`health-check-http-endpoint`	N/A	O ponto final usado para determinar o estado de funcionamento de HTTP se o tipo de verificação de funcionamento for HTTP. Predefinição: `/`
`health-check-invocation-timeout`	N/A	Tempo em segundos entre verificações de funcionamento individuais baseadas em HTTP e portas. Predefinição: 1
`health-check-type`	`--health-check-type`, `-u`	Tipo de verificação de funcionamento a realizar na aplicação. Os valores válidos são: `port`, `http`, `none` e `process`. Predefinição: `port`
`instances`	`-i`	Número de instâncias da app que o Cloud Foundry vai executar. Predefinição: 1
`memory`	`-m`	O limite de memória por instância para a aplicação. As unidades válidas são: `M`, `MB`, `G` ou `GB` Predefinição provável: 1G
`timeout`	`-t`	Número de segundos permitidos entre o início da app e a primeira verificação de funcionamento bem-sucedida. Predefinição provável: 60

Recolha as seguintes informações para o seu projeto Google Cloud e configuração do Cloud Run:

Propriedade	Descrição
`project_number`	O número do projeto do Google Cloud no qual quer fazer a implementação.
`region`	A região para a qual quer implementar a sua app.
`vpc-access-connector`	O nome do conetor de VPC que o administrador da plataforma quer que as aplicações usem.
`vpc-access-egress`	O nome de saída da VPC que o administrador da plataforma quer que as aplicações usem.
`custom-audiences`	Públicos-alvo personalizados que podem ser autenticados na sua aplicação.
`serviceAccountName`	A identidade que a sua aplicação vai usar no Google Cloud.
`image`	A imagem da aplicação que produziu no passo anterior.

Preencha o seguinte modelo num ficheiro service.yaml na raiz do seu projeto

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

Anexe todos os serviços de apoio

Tem de criar uma variável de ambiente VCAP_SERVICES para permitir a injeção de serviços e a deteção pela sua aplicação Cloud Foundry, como Spring ou Steeltoe. Tem de o fazer para cada aplicação que estiver a migrar. Consulte a documentação do Cloud Foundry VCAP_SERVICES para mais informações.

Se a sua aplicação já estiver a ser executada no Cloud Foundry e quiser anexá-la aos mesmos serviços no Cloud Run, pode usar a variável de ambiente existente. Caso contrário, tem de criar um novo VCAP_SERVICES.

Para configurar a variável de ambiente VCAP_SERVICES:

Para um VCAP_SERVICES existente:
1. Experimente obter a variável de ambiente VCAP_SERVICES executando cf env APP_NAME.
2. Se isso não funcionar:
  1. Ligue-se à sua aplicação no Cloud Foundry: cf ssh APP_NAME
  2. Execute o comando env e obtenha o resultado de VCAP_SERVICES.
  3. Saia da sessão SSH executando exit.
3. Guarde o valor VCAP_SERVICES num novo ficheiro denominado vcap.json.
Se quiser adicionar serviços ou estabelecer ligação a serviços diferentes dos do Cloud Foundry, crie um novo VCAP_SERVICES:
1. Num editor de texto, crie um mapa JSON vazio {}
2. Para cada serviço que quer adicionar, faça o seguinte:
3. Consulte a documentação da biblioteca que a sua app usa para analisar VCAP_SERVICES para o tipo que quer adicionar para compreender como descobre a associação.
4. Adicione uma chave ao mapa com o nome do fornecedor de serviços, se ainda não existir. Normalmente, é algo como mysql, postgresql ou elasticsearch. Defina o valor como uma matriz vazia:
5. Adicione um objeto à matriz com as seguintes propriedades:
  1. Metadados que não são normalmente usados para descobrir/associar serviços:
    - binding_name, uma string que representa o recurso que concede autorizações à sua aplicação no serviço. Pode ser um nome de utilizador para uma base de dados, uma regra de firewall, um nome de conta de serviço ou outra coisa.
    - instance_name, uma string que representa o nome do serviço de apoio técnico. Pode ser o nome da sua base de dados, um valor aleatório ou um valor de sentinela para um serviço global.
    - name, o binding_name, se existir; caso contrário, o instance_name. Normalmente, este valor não é importante.
    - label, o valor da chave no mapa VCAP_SERVICES em que esta associação está aninhada.
    - plan, o nome do plano de serviço. Alguns exemplos são: "fornecido pelo utilizador", "alta disponibilidade".
  2. Valores que são frequentemente usados para descobrir/associar serviços:
    - tags Uma lista de etiquetas para ajudar as bibliotecas a encontrar serviços compatíveis. Isto inclui frequentemente o nome comum do serviço, por exemplo, mysql para o MySQL e o MariaDB, redis para o Redis ou o Cloud Memorystore, ou postgres para bases de dados compatíveis com o Postgres.
    - credentials Um objeto que contém as credenciais usadas pela biblioteca do cliente para fazer a ligação. A maioria das bibliotecas de cliente baseia-se num campo uri que contém o URI padrão ou o formato JDBC do serviço.
6. Guarde o conteúdo como vcap.json.

Anexe credenciais ao seu recurso do Cloud Run

Para anexar credenciais:

Crie um segredo para guardar o conteúdo da variável de ambienteVCAP_SERVICES e tome nota da versão emitida pelo comando:
```
gcloud secrets create APP_NAME-vcap \
  --replication-policy="automatic" \
  --data-file=vcap.json
```

Conceda à conta de serviço da sua aplicação autorização para ler o segredo:

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

Adicione a seguinte variável de ambiente à sua aplicação service.yaml no spec.template.spec.containers[0].env array :

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

Modelos para serviços de apoio comuns

As secções seguintes fornecem informações sobre os serviços de apoio usados frequentemente

MySQL

Normalmente, as bibliotecas do MySQL esperam a etiqueta mysql. É comum incluir as seguintes chaves em credentials:

Modelo uri: mysql://username:password@host:port/dbname. A documentação do MySQL pode ajudar a criar uma string de URI. Normalmente, a porta é 3306.
username O nome de utilizador da ligação, obrigatório para algumas bibliotecas, mesmo que esteja incluído em uri
password A palavra-passe de ligação, exigida por algumas bibliotecas, mesmo que incluída em uri

Redis

Normalmente, as bibliotecas Redis esperam a etiqueta redis. É comum incluir as seguintes chaves em credentials:

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

A documentação do URI Redis da IANA pode ajudar a criar uma string de URI. Normalmente, a porta é 6379.

RabbitMQ

Normalmente, as bibliotecas do RabbitMQ esperam a etiqueta rabbitmq e as seguintes chaves em credentials:

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

A documentação do RabbitMQ pode ajudar na criação de uma string de URI. Normalmente, a porta é 5672.

Serviços fornecidos pelos utilizadores

Os serviços fornecidos pelo utilizador são um tipo especial de serviço no Cloud Foundry que lhe permite injetar quaisquer credenciais. A etiqueta é sempre user-provided. As etiquetas são os valores transmitidos para cf create-user-provided-service através da flag -t e as credenciais são os conteúdos da flag -p.

Implementar a sua aplicação

Para implementar a aplicação Cloud Foundry totalmente migrada num serviço do Cloud Run:

Se ainda não o fez, configure o seu ambiente do Cloud Run.
Execute o comando
```
gcloud run services replace service.yaml
```
Aguarde alguns momentos até que a implementação esteja concluída. Se for bem-sucedido, a linha de comando apresenta o URL do serviço.
Visite o serviço implementado abrindo o URL do serviço num navegador de Internet.

Parabéns! Acabou de migrar a sua aplicação Cloud Foundry para o Cloud Run