Esta página foi traduzida pela API Cloud Translation.

Exemplo de migração do Cloud Foundry para o Cloud Run: Spring Music

Esta migração de amostra usa o projeto Spring Music para mostrar como uma aplicação do Cloud Foundry pode ser criada como uma imagem de aplicação compatível com OCI. Este exemplo está a usar a estratégia de migração direta, que usa componentes de código aberto do ecossistema do Cloud Foundry. Depois de criar a imagem da aplicação, tem de configurar a aplicação para implementação no Cloud Run.

Antes de começar

Certifique-se de que configurou um novo projeto para o Cloud Run, conforme descrito na página de configuração.
Certifique-se de que tem um REGISTRY_URI para armazenar contentores. O Cloud Run recomenda a utilização do Artifact Registry.
Se estiver ao abrigo de uma política da organização de restrição de domínio que restringe as invocações não autenticadas para o seu projeto, tem de aceder ao serviço implementado conforme descrito em Testar serviços privados.
Instale o Docker na sua estação de trabalho. O Docker é usado para criar imagens intermédias para criar o projeto.

Autorizações necessárias para a implementação

Para este guia, precisa de autorizações para criar, armazenar a imagem do contentor criada e implementar.

Tem de ter as seguintes funções:

Estrutura do projeto

Para este guia, sugerimos que crie um diretório de projeto, por exemplo, cr-spring-music/ e crie subdiretórios à medida que avança no guia.

cr-spring-music/
├── build
├── run
└── spring-music

Crie a imagem de compilação

Esta secção cria uma imagem de compilação com cflinux3 como imagem base. A imagem de compilação é usada como ambiente de compilação para criar a imagem da aplicação.

Crie um diretório denominado build/ e cd nele:
```
mkdir build && cd build
```

Na pasta build/, crie um novo ficheiro denominado Dockerfile e cole o seguinte código:

ARG CF_LINUX_FS=cloudfoundry/cflinuxfs3

FROM golang:1.20-bullseye AS builder_build
WORKDIR /build
RUN ["git", "clone", "--depth=1", "https://github.com/cloudfoundry/buildpackapplifecycle.git"]
WORKDIR /build/buildpackapplifecycle
RUN ["go", "mod", "init", "code.cloudfoundry.org/buildpackapplifecycle"]
RUN ["go", "mod", "tidy"]
RUN CGO_ENABLD=0 go build -o /builder ./builder/

FROM $CF_LINUX_FS
# Set up container tools related to building applications
WORKDIR /lifecycle
COPY --from=builder_build /builder /lifecycle/builder

# Set up environment to match Cloud Foundry's build.
# https://docs.cloudfoundry.org/devguide/deploy-apps/environment-variable.html#app-system-env
WORKDIR /staging/app
WORKDIR /tmp
ENV CF_INSTANCE_ADDR=127.0.0.1:8080 \
CF_INSTANCE_IP=127.0.0.1 \
CF_INSTANCE_INTERNAL_IP=127.0.0.1 \
VCAP_APP_HOST=127.0.0.1 \
CF_INSTANCE_PORT=8080 \
LANG=en_US.UTF-8 \
INSTANCE_GUID=00000000-0000-0000-0000-000000000000 \
VCAP_APPLICATION={} \
VCAP_SERVICES={} \
CF_STACK=cflinuxfs3

Use o Cloud Build para criar e publicar a imagem builder
```
gcloud builds \
    submit --tag "REGISTRY_URI/builder:stable"
```
Substitua REGISTRY_URI pelo endereço do Artifact Registry onde quer publicar a imagem de compilação. Por exemplo: REGION-docker.pkg.dev/PROJECT_ID/REPOSITORY/builder:stable.

Crie a imagem do tempo de execução

Esta secção cria uma imagem de execução usando cflinux3 como imagem base. A imagem de execução é usada como imagem base quando cria a imagem final da aplicação.

Crie um diretório denominado run/ e cd nele:
```
mkdir run && cd run
```

Na pasta run/, crie um novo script de shell denominado entrypoint.bash com o seguinte código:

#!/usr/bin/env bash
set -e

if [[ "$@" == "" ]]; then
exec /lifecycle/launcher "/home/vcap/app" "" ""
else
exec /lifecycle/launcher "/home/vcap/app" "$@" ""
fi

Na pasta run/, crie um novo ficheiro denominado Dockerfile e cole o seguinte código:

ARG CF_LINUX_FS=cloudfoundry/cflinuxfs3

FROM golang:1.20-bullseye AS launcher_build
WORKDIR /build
RUN ["git", "clone", "--depth=1", "https://github.com/cloudfoundry/buildpackapplifecycle.git"]
WORKDIR /build/buildpackapplifecycle
RUN ["go", "mod", "init", "code.cloudfoundry.org/buildpackapplifecycle"]
RUN ["go", "mod", "tidy"]
RUN CGO_ENABLD=0 go build -o /launcher ./launcher/

FROM $CF_LINUX_FS
# Set up container tools related to launching the application
WORKDIR /lifecycle
COPY entrypoint.bash /lifecycle/entrypoint.bash
RUN ["chmod", "+rx", "/lifecycle/entrypoint.bash"]
COPY --from=launcher_build /launcher /lifecycle/launcher

# Set up environment to match Cloud Foundry
WORKDIR /home/vcap
USER vcap:vcap
ENTRYPOINT ["/lifecycle/entrypoint.bash"]

# Expose 8080 to allow app to be run on Cloud Foundry,
# and PORT so the container can be run locally.
# These do nothing on Cloud Run.
EXPOSE 8080/tcp
# Set up environment variables similar to Cloud Foundry.
ENV CF_INSTANCE_ADDR=127.0.0.1:8080 \
CF_INSTANCE_IP=127.0.0.1 \
INSTANCE_IP=127.0.0.1 \
CF_INSTANCE_INTERNAL_IP=127.0.0.1 \
VCAP_APP_HOST=127.0.0.1 \
CF_INSTANCE_PORT=80 \
LANG=en_US.UTF-8 \
CF_INSTANCE_GUID=00000000-0000-0000-0000-000000000000 \
INSTANCE_GUID=00000000-0000-0000-0000-000000000000 \
CF_INSTANCE_INDEX=0 \
INSTANCE_INDEX=0 \
PORT=8080 \
VCAP_APP_PORT=8080 \
VCAP_APPLICATION={} \
VCAP_SERVICES={}

Use o Cloud Build para criar e publicar a imagem runtime:
```
gcloud builds submit \
    --tag "REGISTRY_URI/runtime:stable"
```
Substitua REGISTRY_URI pelo endereço do Artifact Registry onde quer publicar a imagem de compilação. Por exemplo: REGION-docker.pkg.dev/PROJECT_ID/REPOSITORY/runtime:stable.

Crie o Spring Music para o Cloud Foundry

Para clonar o projeto Spring Music e executar os comandos de compilação como se estivéssemos a implementar o projeto no Cloud Foundry:

Clone o repositório Spring Music:

git clone https://github.com/cloudfoundry-samples/spring-music.git

Para os fins deste guia, vamos usar uma versão mais antiga da aplicação Spring Music que usa o Java 8 e o Spring Boot 2. Para tal, vamos mudar para uma revisão mais antiga do projeto Spring Music:
```
git checkout 610ba471a643a20dee7a62d88a7879f13a21d6a3
```
Mova-o para o repositório:
```
cd spring-music
```
Crie o binário do Spring Music:
```
./gradlew clean assemble
```

Agora, tem uma pasta build/ com a app Spring Music compilada pronta para ser enviada para uma instância do Cloud Foundry.

Converta o Spring Music numa aplicação compatível com o Cloud Run

Tem de usar o resultado do comando de compilação para preparar o artefacto do Spring Music para implementação no Cloud Run.

Crie um diretório de preparação cr-app e um subdiretório src no interior:
```
mkdir -p cr-app/src
```
Imite o comando cf push extraindo o conteúdo do JAR compilado para o diretório src:
```
unzip build/libs/spring-music-1.0.jar -d cr-app/src
```
Altere o diretório para cr-app/:
```
cd cr-app/
```
Cria um novo ficheiro denominado Dockerfile. Este Dockerfile usa a imagem de compilação e a imagem de tempo de execução criadas nos passos anteriores para criar a imagem da aplicação executável para o Spring Music, usando o buildpack Java.

Cole o seguinte código em Dockerfile:

ARG BUILD_IMAGE
ARG RUN_IMAGE
FROM $BUILD_IMAGE as build

COPY src /staging/app
COPY src /tmp/app

ARG BUILDPACKS
RUN /lifecycle/builder \
-buildArtifactsCacheDir=/tmp/cache \
-buildDir=/tmp/app \
-buildpacksDir=/tmp/buildpacks \
-outputBuildArtifactsCache=/tmp/output-cache \
-outputDroplet=/tmp/droplet \
-outputMetadata=/tmp/result.json \
"-buildpackOrder=${BUILDPACKS}" \
"-skipDetect=true"

FROM $RUN_IMAGE
COPY --from=build /tmp/droplet droplet
RUN tar -xzf droplet && rm droplet

Crie o Spring Music como uma imagem compatível com OCI

Neste passo, indica ao Cloud Build como criar uma imagem compatível com OCI usando a imagem de compilação, a imagem de tempo de execução e o Dockerfile da aplicação criados nos passos anteriores.

Para criar a imagem compatível com OCI:

Cria um ficheiro denominado cloudbuild.yaml. Esta é uma configuração de compilação que indica ao Cloud Build como compilar a aplicação.

Cole a seguinte configuração em cloudbuild.yaml:

steps:
- name: gcr.io/cloud-builders/docker
  args:
  - 'build'
  - '--network'
  - 'cloudbuild'
  - '--tag'
  - '${_TAG}'
  - '--build-arg'
  - 'BUILD_IMAGE=${_BUILD_IMAGE}'
  - '--build-arg'
  - 'RUN_IMAGE=${_RUN_IMAGE}'
  - '--build-arg'
  - 'BUILDPACKS=${_BUILDPACKS}'
  - '.'
images:
- "${_TAG}"
options:
  # Substitute build environment variables as an array of KEY=VALUE formatted strings here.
  env: []
substitutions:
  _BUILD_IMAGE: REGISTRY_URI/builder:stable
  _RUN_IMAGE:  REGISTRY_URI/runtime:stable
  _BUILDPACKS: https://github.com/cloudfoundry/java-buildpack
  _TAG: REGISTRY_URI/spring-music:latest

Substitua REGISTRY_URI pelo URI do registo de contentores onde publicou o criador e o executor.

Crie a imagem da aplicação através do Cloud Build:
```
gcloud builds submit .
```
Quando a compilação estiver concluída, tome nota do URI da imagem resultante. Vai precisar dela quando implementar a aplicação nos passos seguintes. A imagem resultante será uma imagem de contentor compatível com OCI para executar a app Spring Music, criada com componentes de código aberto do Cloud Foundry.

Implemente no Cloud Run

Tem de criar um ficheiro de definição de serviço para usar no Cloud Run:

Crie uma conta de serviço para a sua aplicação:

gcloud iam service-accounts create spring-music

Crie um ficheiro service.yaml com o seguinte código:

apiVersion: serving.knative.dev/v1
kind: Service
metadata:
  name: "spring-music"
  # Set this to be the project number of the project you're deploying to.
  namespace: "PROJECT_NUMBER"
  labels:
    cloud.googleapis.com/location: us-central1
    migrated-from: cloud-foundry
  annotations:
    run.googleapis.com/ingress: all
spec:
  template:
    metadata:
      annotations:
        autoscaling.knative.dev/minScale: '1'
        autoscaling.knative.dev/maxScale: '1'
        run.googleapis.com/cpu-throttling: 'true'
        run.googleapis.com/startup-cpu-boost: 'true'
        run.googleapis.com/sessionAffinity: 'false'
    spec:
      containerConcurrency: 1000
      timeoutSeconds: 900
      serviceAccountName: spring-music@PROJECT_NUMBER.iam.gserviceaccount.com
      containers:
      - name: user-container
        # Set the following value to either:
        # - The image you built for your application in the last section of the guide.
        image: SPRING_IMAGE_URI
        ports:
        - name: http1
          containerPort: 8080
        env:
        - name: VCAP_APPLICATION
          value: |-
                {
                    "application_id": "00000000-0000-0000-0000-000000000000",
                    "application_name": "spring-music",
                    "application_uris": [],
                    "limits": {
                    "disk": 0,
                    "mem": 1024
                    },
                    "name": "spring-music",
                    "process_id": "00000000-0000-0000-0000-000000000000",
                    "process_type": "web",
                    "space_name": "none",
                    "uris": []
                }
        - name: MEMORY_LIMIT
          value: '1024M'
        resources:
          limits:
            memory: 1024Mi
            cpu: "1"
        startupProbe:
          httpGet:
            path: /
            port: 8080
          timeoutSeconds: 1
          failureThreshold: 30
          successThreshold: 1
          periodSeconds: 2
        livenessProbe:
          httpGet:
            path: /
            port: 8080
          timeoutSeconds: 1
          failureThreshold: 1
          successThreshold: 1
          periodSeconds: 30
  traffic:
  - percent: 100
    latestRevision: true

Substitua PROJECT_NUMBER pelo número do seu projeto.
Substitua SPRING_IMAGE_URI pelo URI da imagem da aplicação criada em criar o Spring Music como uma imagem compatível com OCI.

Implemente o serviço no Cloud Run:
```
gcloud run services replace service.yaml
```
Assim que a implementação estiver concluída, pode visitar a aplicação Spring Music em execução no URL implementado.

O que se segue

Para uma análise mais detalhada do processo de contentorização, consulte o artigo Migre para contentores OCI.

Exemplo de migração do Cloud Foundry para o Cloud Run: Spring Music Mantenha tudo organizado com as coleções Salve e categorize o conteúdo com base nas suas preferências.