Questa pagina è stata tradotta dall'API Cloud Translation.

Esegui la migrazione ai container OCI

Questa pagina descrive l'infrastruttura di compilazione necessaria per riprodurre il processo di compilazione di Cloud Foundry durante la generazione di immagini delle applicazioni compatibili con OCI. Se hanno già completato la guida alla migrazione a Spring Music puoi approfondire l'argomento delle configurazioni di migrazione specifiche un'applicazione.

Diagramma che descrive come creare immagini OCI utilizzando strumenti moderni

Prima di iniziare

Assicurati di aver configurato un nuovo progetto per Cloud Run come descritto nella pagina Configurazione di Cloud Run.
Assicurati di avere un REGISTRY_URI per l'archiviazione dei contenitori. Cloud Run consiglia di utilizzare Artifact Registry. Docker viene utilizzato per creare immagini intermedie per creare progetto.

Configurazione di un processo di compilazione compatibile con Cloud Foundry

Per supportare questa nuova procedura, devi creare due contenitori OCI di base:

Un'immagine del generatore che rispecchia il processo di compilazione di Cloud Foundry ed è in grado di compilare il codice sorgente dell'applicazione nei droplet Cloud Foundry.
Un'immagine di runtime che riflette il runtime dell'applicazione Cloud Foundry.

Questo processo deve essere eseguito almeno una volta dagli amministratori della piattaforma. Una volta stabilito il processo, le immagini di compilazione ed esecuzione possono essere condivise da tutte le applicazioni Cloud Foundry che devono eseguire la migrazione a Cloud Run.

Crea l'immagine del builder

Questa sezione crea un'immagine di compilazione utilizzando cflinux3 come immagine di base. L'immagine di build viene utilizzata come ambiente di compilazione per la creazione l'immagine dell'applicazione.

Crea una directory denominata build/ e cd al suo interno:
```
mkdir build && cd build
```

Nella cartella build/, crea un nuovo file denominato Dockerfile e incollalo nella cartella il seguente codice:

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

Utilizza Cloud Build per creare e pubblicare l'immagine builder
```
gcloud builds \
    submit --tag "REGISTRY_URI/builder:stable"
```
Sostituisci REGISTRY_URI con l'indirizzo di Artifact Registry in cui vuoi pubblicare l'immagine di compilazione. Ad esempio: REGION-docker.pkg.dev/PROJECT_ID/REPOSITORY/builder:stable.

crea l'immagine di runtime

Questa sezione crea un'immagine di esecuzione utilizzando cflinux3 come immagine di base. L'immagine di esecuzione viene utilizzata come immagine di base quando crei l'immagine l'immagine dell'applicazione.

Crea una directory denominata run/ e cd al suo interno:
```
mkdir run && cd run
```

Nella cartella run/, crea un nuovo script shell denominato entrypoint.bash con il seguente codice:

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

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

Nella cartella run/, crea un nuovo file denominato Dockerfile e incolla il seguente codice:

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={}

Utilizza Cloud Build per creare e pubblicare l'immagine runtime:
```
gcloud builds submit \
    --tag "REGISTRY_URI/runtime:stable"
```
Sostituisci REGISTRY_URI con l'indirizzo in Artifact Registry dove vuoi per pubblicare l'immagine build. Ad esempio: REGION-docker.pkg.dev/PROJECT_ID/REPOSITORY/runtime:stable.

Creazione di applicazioni Cloud Foundry come immagini OCI

Ogni applicazione di cui è stata eseguita la migrazione in Cloud Run ha bisogno del proprio Dockerfile che corrisponda al modo in cui Cloud Foundry esegue le applicazioni. Il Dockerfile esegue queste operazioni:

Carica l'immagine del generatore.
Esegue il ciclo di vita del buildpack v2 per creare un droplet.
Estrae il contenuto della goccia.
Carica i contenuti della droplet sull'immagine di esecuzione per creare l'immagine dell'applicazione.

L'immagine dell'applicazione finale è compatibile sia con Cloud Foundry sia con Cloud Run, quindi puoi eseguire test A/B della migrazione per facilitare il debug di eventuali comportamenti imprevisti.

Questa procedura deve essere eseguita dal team delle applicazioni per ogni applicazione di cui è necessaria la migrazione.

Raccogli informazioni sulle build da un'applicazione Cloud Foundry di cui è stato eseguito il deployment

Osserva lo stack di applicazioni. Lo stack viene fornito tramite il flag -s in cf push o il campo stack del file manifest dell'applicazione.
1. Se lo stack è Windows, è probabile che l'applicazione non sia compatibile con Cloud Run. Prima di continuare, devi portare l'applicazione su Linux.
2. Se lo stack è vuoto, cflinuxfs3 o cflinuxfs4, è possibile eseguire la migrazione dell'applicazione a Cloud Run.

Raccogli l'elenco dei buildpack dell'applicazione. I buildpack vengono forniti tramite il flag -b in cf push, il campo buildpack nel file manifest dell'applicazione o il campo buildpacks del file manifest dell'applicazione.

In caso contrario se vengono specificati, i buildpack vengono rilevati automaticamente. Osserva la dei buildpack rilevati nel deployment più recente dell'applicazione in Cloud Foundry o specificali esplicitamente se conosci i percorsi.
Se i buildpack sono URL, prendine nota e vai al passaggio successivo.

Per tutti i buildpack che utilizzano un nome breve, utilizza la seguente tabella per mapparli agli URL:

Nome breve	URL
`staticfile_buildpack`	https://github.com/cloudfoundry/staticfile-buildpack
`java_buildpack`	https://github.com/cloudfoundry/java-buildpack
`ruby_buildpack`	https://github.com/cloudfoundry/ruby-buildpack
`dotnet_core_buildpack`	https://github.com/cloudfoundry/dotnet-core-buildpack
`nodejs_buildpack`	https://github.com/cloudfoundry/nodejs-buildpack
`go_buildpack`	https://github.com/cloudfoundry/go-buildpack
`python_buildpack`	https://github.com/cloudfoundry/python-buildpack
`php_buildpack`	https://github.com/cloudfoundry/php-buildpack
`binary_buildpack`	https://github.com/cloudfoundry/binary-buildpack
`nginx_buildpack`	https://github.com/cloudfoundry/nginx-buildpack

Il codice sorgente dei buildpack meno comuni è disponibile in Cloud Foundry Organizzazione GitHub.

Raccogli la posizione del codice sorgente dell'immagine. L'origine viene fornita tramite l'attributo path del manifest dell'applicazione o il flag -p del comando cf push. Se l'origine non è definita, si riferisce all'attuale .
Determina se nella directory del codice sorgente è presente un file .cfignore. Se è presente, spostalo in un file denominato .gcloudignore.

Crea l'applicazione Cloud Foundry

In questo passaggio, organizzerai gli elementi build nel seguente struttura delle cartelle:

.
├── cloudbuild.yaml
├── Dockerfile
├── .gcloudignore
└── src
    ├── go.mod
    └── main.go

cloudbuild.yaml fornisce a Cloud Build istruzioni di build specifiche
Dockerfile utilizzerà la build ed eseguirà le immagini dei passaggi precedenti per creare l'immagine dell'applicazione
src/ contiene il codice sorgente dell'applicazione

Crea un file denominato Dockerfile nella directory con i seguenti contenuti:

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

Crea un file denominato cloudbuild.yaml nella directory con quanto segue contenuti:

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: BUILD_IMAGE_URI
  _RUN_IMAGE:  RUN_IMAGE_URI
  _BUILDPACKS: BUILDPACK_URL
  _TAG: APP_ARTIFACT_REGISTRY/APP_NAME:latest

Sostituisci BUILD_IMAGE_URI con l'URI dell'immagine di compilazione creata nei passaggi precedenti.
Sostituisci RUN_IMAGE_URI con l'URI dell'immagine di esecuzione creata nei passaggi precedenti.
Sostituisci BUILDPACK_URL con gli URL dei buildpack utilizzata dalla tua applicazione. Può essere un elenco separato da virgole contenente più i buildpack.

Se hai un file .cfignore, copialo nella directory con il nome .gcloudignore.
Crea nella directory una directory denominata src.
Copia i contenuti della tua applicazione in src:
1. Se l'origine è un file ZIP (inclusi i file .jar), decomprimi i contenuti in src.
2. Se il codice sorgente è una directory, copia i contenuti in src.
Esegui gcloud builds submit . per creare la tua applicazione.

Incompatibilità note

I buildpack che si basano su variabili di ambiente iniettate da Cloud Foundry come VCAP_SERVICES non funzioneranno. Devi dichiarare esplicitamente una dipendenza su ciò che inseriscono usando il sistema di gestione della tua lingua.
Per applicare patch alle immagini prodotte in questo modo, devi ricostruire l'immagine utilizzando una versione più recente dell'immagine di compilazione ed esecuzione. Le immagini dell'applicazione non saranno la patch applicata automaticamente mediante l'aggiornamento delle derivazioni BOSH se le esegui su Cloud Foundry.
Le build vengono eseguite in un ambiente di rete diverso da quello di Cloud Foundry potresti dover configurare pool Cloud Build personalizzati con accesso del pacchetto interno.

Passaggi successivi

Eseguire la migrazione delle configurazioni delle applicazioni