Questa pagina descrive l'infrastruttura di build necessaria per riprodurre il cloud Processo di compilazione Foundry durante la generazione di immagini dell'applicazione 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.
Prima di iniziare
- Assicurati di aver configurato un nuovo progetto per Cloud Run come descritto nella pagina di configurazione di Cloud Run.
- Assicurati di avere un
REGISTRY_URI
per l'archiviazione containers. 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 questo nuovo processo, devi creare due container OCI di base:
- Un'immagine builder che rispecchia il processo di compilazione di Cloud Foundry e che è in grado di creare codice sorgente dell'applicazione nelle 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 processo è stabilito, le immagini di build ed esecuzione possono essere condivise Applicazioni Cloud Foundry che richiedono la migrazione a Cloud Run.
Crea l'immagine del builder
Questa sezione crea un'immagine build utilizzando cflinux3
come base
dell'immagine. L'immagine di build viene utilizzata come ambiente di compilazione per la creazione
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 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 build. 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 base
dell'immagine. L'immagine di esecuzione viene utilizzata come immagine di base quando crei l'immagine
l'immagine dell'applicazione.
Crea una directory denominata
run/
ecd
al suo interno:mkdir run && cd run
Nella cartella
run/
, crea un nuovo script shell chiamatoentrypoint.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 codice seguente: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 migrata in Cloud Run richiede la propria il tuo Dockerfile che corrisponde al modo in cui Cloud Foundry esegue le applicazioni. Il Dockerfile esegue queste operazioni:
- Carica l'immagine del builder.
- Esegue il ciclo di vita del buildpack v2 per creare una droplet.
- Estrae il contenuto della goccia.
- Carica i contenuti della droplet sull'immagine di esecuzione per creare l'immagine dell'applicazione.
L'immagine finale dell'applicazione è compatibile sia con Cloud Foundry che Cloud Run per eseguire test A/B della migrazione per eseguire il debug di comportamenti imprevisti.
Questa procedura deve essere eseguita dal team addetto alla candidatura per ogni domanda. di cui è necessario eseguire 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
incf push
o il campostack
del file manifest dell'applicazione.- Se lo stack è Windows, è probabile che l'applicazione non sia compatibile con Cloud Run. Prima di continuare, devi portare l'applicazione su Linux.
- Se lo stack è vuoto,
cflinuxfs3
ocflinuxfs4
l'applicazione è possibile eseguire la migrazione a Cloud Run.
Raccogli l'elenco dei buildpack dell'applicazione. I buildpack vengono forniti tramite il flag
-b
incf push
, il campobuildpack
nella richiesta o il campobuildpacks
del manifest dell'applicazione.- In caso contrario se vengono specificati, i buildpack vengono rilevati automaticamente. Guarda la dei buildpack rilevati nel deployment più recente dell'applicazione Cloud Foundry o specificali esplicitamente se conosci i percorsi.
- Se i buildpack sono URL, prendi nota degli URL 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 è fornita tramite Attributo
path
del manifest dell'applicazione o il flag-p
del comandocf push
. Se l'origine non è definita, si riferisce all'attuale .Determina se è presente un file
.cfignore
nella directory del codice sorgente. Se si trova lì, 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 specificheDockerfile
utilizzerà la build ed eseguirà le immagini dei passaggi precedenti per creare l'immagine dell'applicazionesrc/
contiene il codice sorgente della tua applicazione
Crea un file denominato
Dockerfile
nella directory con il seguente contenuto: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 del immagine build creata nei passaggi precedenti. - Sostituisci
RUN_IMAGE_URI
con l'URI del esegui immagine 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.
- Sostituisci
Se hai un file
.cfignore
, copialo nella directory con il nome.gcloudignore
.Crea nella directory una directory denominata
src
.Copia i contenuti dell'applicazione in
src:
- Se l'origine è un file ZIP (inclusi i file
.jar
), decomprimi i contenuti insrc
. - Se il codice sorgente è una directory, copia il contenuto in
src
.
- Se l'origine è un file ZIP (inclusi i file
Esegui
gcloud builds submit .
per creare la tua applicazione.
Incompatibilità note
- Buildpack che si basano su variabili di ambiente inserite da Cloud Foundry come
VCAP_SERVICES
non funzionerà. Devi dichiarare esplicitamente una dipendenza su ciò che inseriscono usando il sistema di gestione della tua lingua. - Per applicare una patch alle immagini prodotte in questo modo, devi ricreare l'immagine usando una versione più recente della build ed esegui l'immagine. Le immagini dell'applicazione non saranno la patch applicata automaticamente mediante l'aggiornamento delle derivazioni BOSH se le esegui su Cloud Foundry.
- Le build verranno eseguite in un ambiente di rete diverso da quello di Cloud Foundry potresti dover configurare pool Cloud Build personalizzati con accesso del pacchetto interno.