Esta página foi traduzida pela API Cloud Translation.

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

Este exemplo de migração usa o projeto Spring Music para mostrar como um aplicativo do Cloud Foundry pode ser criado como uma imagem de aplicativo compatível com OCI. Neste exemplo, usamos a estratégia de migração lift-and-shift, que utiliza componentes de código aberto do ecossistema do Cloud Foundry. Depois de criar a imagem do aplicativo, é necessário configurá-lo para implantação no Cloud Run.

Antes de começar

Verifique se você configurou um novo projeto para o Cloud Run conforme descrito na página de configuração.
Verifique se você tem um REGISTRY_URI para armazenar contêineres. O Cloud Run recomenda o uso do Artifact Registry.
Se você precisa seguir uma política da organização de restrição de domínio que restringe invocações não autenticadas para seu projeto, será necessário acessar o serviço implantado, conforme descrito em Como testar serviços particulares.
Instale o Docker na sua estação de trabalho. Ele é usado na criação de imagens intermediárias para o projeto.

Permissões necessárias para implantar

Para este guia, você precisa de permissões para criar, armazenar a imagem de contêiner criada e implantá-la.

Você precisa ter os seguintes papéis:

Estrutura do projeto

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

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

Criar a imagem do build

Nesta seção, criamos uma imagem de build usando cflinux3 como a imagem de base. A imagem de build é usada como o ambiente de build para criar a imagem do aplicativo.

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

Na pasta build/, crie um novo arquivo chamado 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

Usar 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 em que você quer publicar a imagem do build. Por exemplo: REGION-docker.pkg.dev/PROJECT_ID/REPOSITORY/builder:stable.

Criar a imagem de ambiente de execução

Nesta seção, criamos uma imagem de execução usando cflinux3 como a imagem de base. A imagem de execução é usada como a imagem de base quando você cria a imagem final do aplicativo.

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

Na pasta run/, crie um novo script de shell chamado 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 arquivo chamado Dockerfile e cole este 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 em que você quer publicar a imagem do build. Por exemplo: REGION-docker.pkg.dev/PROJECT_ID/REPOSITORY/runtime:stable.

Compilar o Spring Music para o Cloud Foundry

Para clonar o projeto Spring Music e executar os comandos de compilação como se a implantação dele estivesse ocorrendo no Cloud Foundry:

Clone o repositório Spring Music:

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

Para os fins deste guia, usaremos uma versão mais antiga do aplicativo Spring Music que usa o Java 8 e o Spring Boot 2. Para fazer isso, 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 você tem uma pasta build/ com o app Spring Music compilado pronto para ser enviado a uma instância do Cloud Foundry.

Converter o Spring Music em um aplicativo compatível com o Cloud Run

Use a saída do comando de build para preparar o artefato Spring Music para implantação no Cloud Run.

Crie um diretório de teste cr-app e um subdiretório src dentro dele:
```
mkdir -p cr-app/src
```
Simule 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/
```
Crie um novo arquivo chamado Dockerfile. Este Dockerfile usará a imagem do build e a imagem do ambiente de execução criadas nas etapas anteriores para criar a imagem do aplicativo executável para o Spring Music usando o buildpack do Java.

Cole o seguinte código no 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

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

Nesta etapa, você instruirá o Cloud Build a criar uma imagem compatível com OCI usando a imagem de build, a imagem de ambiente de execução e o Dockerfile do aplicativo criados nas etapas anteriores.

Para criar uma imagem compatível com OCI:

Crie um arquivo chamado cloudbuild.yaml. Essa é uma configuração de compilação que instrui o Cloud Build a criar o aplicativo.

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 registro do contêiner em que você publicou o builder e o executor.

Crie a imagem usando o Cloud Build:
```
gcloud builds submit .
```
Quando o build for concluído, anote o URI da imagem resultante. Você precisará dele quando implantar o aplicativo nas próximas etapas. A imagem resultante será uma imagem de contêiner compatível com OCI para executar o aplicativo Spring Music, criada usando componentes de código aberto do Cloud Foundry.

Implantar no Cloud Run

É preciso criar um arquivo de definição de serviço para usar no Cloud Run:

Crie uma conta de serviço para seu aplicativo:

gcloud iam service-accounts create spring-music

Crie um arquivo service.yaml com o seguinte conteúdo.

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 projeto.
Substitua SPRING_IMAGE_URI pelo URI da imagem do aplicativo criada em criar Spring Music como uma imagem compatível com OCI.

Implante o serviço no Cloud Run:
```
gcloud run services replace service.yaml
```
Depois que a implantação for concluída, você poderá acessar o aplicativo Spring Music em execução no URL implantado.

Próximas etapas

Para uma visão mais detalhada do processo de conteinerização, consulte Migrar para contêineres OCI.