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 hai già completato la guida alla migrazione di Spring Music, puoi utilizzare questa pagina per approfondire le configurazioni di migrazione specifiche per la tua applicazione.
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 compilare il 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 rispecchia il runtime dell'applicazione Cloud Foundry.
Questa procedura deve essere eseguita 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 compilazione viene utilizzata come ambiente di compilazione per creare l'immagine dell'applicazione.
Crea una directory denominata
build/
ecd
al suo interno:mkdir build && cd build
Nella cartella
build/
, crea un nuovo file denominatoDockerfile
e incolla 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 per creare l'immagine dell'applicazione finale.
Crea una directory denominata
run/
ecd
al suo interno:mkdir run && cd run
Nella cartella
run/
, crea un nuovo script shell denominatoentrypoint.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 denominatoDockerfile
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 di Artifact Registry in cui vuoi pubblicare l'immagine di compilazione. 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 le seguenti operazioni:
- Carica l'immagine del builder.
- Esegue il ciclo di vita del buildpack v2 per creare un droplet.
- Estrae i contenuti del droplet.
- Carica i contenuti del droplet nell'immagine di esecuzione per creare l'immagine dell'applicazione eseguibile.
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 inaspettati.
Questa procedura deve essere eseguita dal team delle applicazioni per ogni applicazione di cui è necessaria la migrazione.
Raccogliere informazioni sulla compilazione da un'applicazione Cloud Foundry di cui è stato eseguito il deployment
Esamina la pila di applicazioni. Lo stack viene fornito tramite il flag
-s
incf push
o nel campostack
del manifest dell'applicazione.- Se lo stack è Windows, è probabile che l'applicazione non sia compatibile con Cloud Run. Prima di continuare, devi eseguire il porting dell'applicazione su Linux.
- Se lo stack è vuoto,
cflinuxfs3
ocflinuxfs4
, è possibile eseguire la migrazione dell'applicazione a Cloud Run.
Raccogliere l'elenco dei buildpack dell'applicazione. I buildpack vengono forniti tramite il flag
-b
incf push
, il campobuildpack
nel file manifest dell'applicazione o il campobuildpacks
del file manifest dell'applicazione.- Se non vengono specificati buildpack, significa che vengono rilevati automaticamente. Consulta l'elenco dei buildpack rilevati nel deployment dell'applicazione più recente in Cloud Foundry o specificali esplicitamente se conosci i percorsi.
- Se i buildpack sono URL, prendine nota e vai al passaggio successivo.
Per qualsiasi buildpack che utilizza 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 nell'organizzazione GitHub di Cloud Foundry.
Recupera la posizione del codice sorgente dell'immagine. L'origine viene fornita tramite l'attributo
path
del manifest dell'applicazione o il flag-p
del comandocf push
. Se l'origine non è definita, fa riferimento alla directory corrente.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, organizza gli elementi di compilazione nella seguente struttura di cartelle:
.
├── cloudbuild.yaml
├── Dockerfile
├── .gcloudignore
└── src
├── go.mod
└── main.go
cloudbuild.yaml
fornisce a Cloud Build istruzioni di compilazione specificheDockerfile
utilizzerà le immagini di compilazione ed esecuzione dei passaggi precedenti per creare l'immagine dell'applicazionesrc/
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 il seguente contenuto: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 utilizzati dalla tua applicazione. Può essere un elenco separato da virgole con più buildpack.
- Sostituisci
Se hai un file
.cfignore
, copialo nella directory con il nome.gcloudignore
.Crea una directory denominata
src
nella directory.Copia i contenuti della tua applicazione in
src:
- Se l'origine è un file ZIP (inclusi i file
.jar
), decomprimi i contenuti insrc
. - Se il codice sorgente è una directory, copia i contenuti in
src
.
- Se l'origine è un file ZIP (inclusi i file
Esegui
gcloud builds submit .
per compilare l'applicazione.
Incompatibilità note
- I buildpack che si basano su variabili di ambiente iniettate da Cloud Foundry come
VCAP_SERVICES
non funzioneranno. Dovresti invece dichiarare esplicitamente una dipendenza da ciò che iniettano utilizzando 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 delle applicazioni non verranno messe automaticamente in patch aggiornando le stemcell BOSH se le esegui su Cloud Foundry.
- Le build verranno eseguite in un ambiente di rete diverso da quello del tuo cluster Cloud Foundry. Potresti dover configurare pool Cloud Build personalizzati con accesso ai mirror dei pacchetti interni.