Halaman ini diterjemahkan oleh Cloud Translation API.

Bermigrasi ke container OCI

Halaman ini menjelaskan infrastruktur build yang diperlukan untuk mereproduksi proses build Cloud Foundry saat membuat image aplikasi yang kompatibel dengan OCI. Jika Anda telah menyelesaikan Panduan migrasi Spring Music, Anda dapat menggunakannya untuk memahami konfigurasi migrasi tertentu untuk aplikasi Anda.

Diagram yang menjelaskan cara membuat image OCI menggunakan
alat modern

Sebelum memulai

Pastikan Anda telah menyiapkan project baru untuk Cloud Run seperti yang dijelaskan pada halaman Penyiapan Cloud Run.
Pastikan Anda memiliki REGISTRY_URI untuk menyimpan container. Cloud Run merekomendasikan penggunaan Artifact Registry. Docker digunakan untuk membuat image menengah untuk membangun project.

Menyiapkan proses build yang kompatibel dengan Cloud Foundry

Anda harus membuat dua container OCI dasar untuk mendukung proses baru ini:

Image builder yang mencerminkan proses build Cloud Foundry dan mampu membangun kode sumber aplikasi menjadi droplet Cloud Foundry.
Image runtime yang mencerminkan runtime aplikasi Cloud Foundry.

Proses ini perlu dilakukan setidaknya sekali oleh administrator platform. Setelah proses ditetapkan, image build dan run dapat dibagikan oleh semua aplikasi Cloud Foundry yang perlu bermigrasi ke Cloud Run.

Membuat image builder

Bagian ini membuat image build menggunakan cflinux3 sebagai image dasar. Image build digunakan sebagai lingkungan build untuk membuat image aplikasi.

Buat direktori bernama build/ dan cd ke dalamnya:
```
mkdir build && cd build
```

Di folder build/, buat file baru bernama Dockerfile dan tempelkan kode berikut:

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

Gunakan Cloud Build untuk membangun dan memublikasikan image builder
```
gcloud builds \
    submit --tag "REGISTRY_URI/builder:stable"
```
Ganti REGISTRY_URI dengan alamat Artifact Registry tempat Anda ingin memublikasikan image build. Contoh: REGION-docker.pkg.dev/PROJECT_ID/REPOSITORY/builder:stable.

Membuat image runtime

Bagian ini membuat image run menggunakan cflinux3 sebagai image dasar. Image run digunakan sebagai image dasar saat Anda membuat image aplikasi akhir.

Buat direktori bernama run/ dan cd ke dalamnya:
```
mkdir run && cd run
```

Di folder run/, buat skrip shell baru bernama entrypoint.bash dengan kode berikut:

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

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

Di folder run/, buat file baru bernama Dockerfile dan tempelkan kode berikut:

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

Gunakan Cloud Build untuk membangun dan memublikasikan image runtime:
```
gcloud builds submit \
    --tag "REGISTRY_URI/runtime:stable"
```
Ganti REGISTRY_URI dengan alamat ke Artifact Registry tempat Anda ingin memublikasikan image build. Contoh: REGION-docker.pkg.dev/PROJECT_ID/REPOSITORY/runtime:stable.

Membangun aplikasi Cloud Foundry sebagai image OCI

Setiap aplikasi yang dimigrasikan ke Cloud Run memerlukan Dockerfile-nya sendiri yang cocok dengan cara Cloud Foundry menjalankan aplikasi. Dockerfile melakukan hal berikut:

Memuat image builder.
Menjalankan siklus proses buildpack v2 untuk membuat droplet.
Mengekstrak konten droplet.
Memuat konten droplet pada image run untuk membuat image aplikasi yang dapat dijalankan.

Image aplikasi akhir kompatibel dengan Cloud Foundry dan Cloud Run sehingga Anda dapat melakukan pengujian A/B terhadap migrasi Anda untuk membantu men-debug perilaku yang tidak terduga.

Proses ini harus dilakukan oleh tim aplikasi untuk setiap aplikasi yang perlu dimigrasikan.

Mengumpulkan informasi build dari aplikasi Cloud Foundry yang di-deploy

Lihat pada stack aplikasi. Stack tersebut disediakan melalui flag -s di kolom cf push atau stack dalam manifes aplikasi.
1. Jika stack-nya adalah Windows, aplikasi tersebut mungkin tidak kompatibel dengan Cloud Run. Anda harus mentransfer aplikasi ke Linux sebelum melanjutkan.
2. Jika stack kosong, cflinuxfs3, atau cflinuxfs4, aplikasi dapat dimigrasikan ke Cloud Run.

Kumpulkan daftar buildpack aplikasi. Buildpack disediakan melalui flag -b di cf push, kolom buildpack dalam manifes aplikasi, atau kolom buildpacks dari manifes aplikasi.

Jika tidak ada buildpack yang ditentukan, berarti build tersebut terdeteksi secara otomatis. Lihat daftar buildpack yang terdeteksi dalam deployment aplikasi terbaru Anda di Cloud Foundry, atau tentukan secara eksplisit jika Anda mengetahui jalurnya.
Jika buildpack adalah URL, catat URL-nya dan lanjutkan ke langkah berikutnya.

Untuk buildpack yang menggunakan nama pendek, gunakan tabel berikut untuk memetakannya ke URL:

Nama Pendek	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

Sumber untuk buildpack yang kurang umum dapat ditemukan di organisasi GitHub Cloud Foundry.

Kumpulkan lokasi kode sumber untuk image. Sumber disediakan melalui atribut path dari manifes aplikasi atau flag -p dari perintah cf push. Jika sumber tidak ditentukan, sumber akan merujuk ke direktori saat ini.
Tentukan apakah ada file .cfignore di direktori kode sumber. Jika ada, pindahkan ke file bernama .gcloudignore.

Membangun aplikasi Cloud Foundry

Pada langkah ini, Anda akan menyusun elemen build ke dalam struktur folder berikut:

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

cloudbuild.yaml menyediakan Cloud Build dengan petunjuk build tertentu
Dockerfile akan menggunakan image build dan run dari langkah sebelumnya untuk membuat image aplikasi
src/ berisi kode sumber aplikasi Anda

Buat file bernama Dockerfile di direktori dengan konten berikut:

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

Buat file bernama cloudbuild.yaml di direktori dengan konten berikut:

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

Ganti BUILD_IMAGE_URI dengan URI image build yang dibuat di langkah sebelumnya.
Ganti RUN_IMAGE_URI dengan URI image run yang dibuat di langkah sebelumnya.
Ganti BUILDPACK_URL dengan URL buildpack yang digunakan oleh aplikasi Anda. Hal ini dapat berupa daftar yang dipisahkan koma dengan beberapa buildpack.

Jika Anda memiliki file .cfignore, salin file tersebut ke direktori dengan nama .gcloudignore.
Buat direktori bernama src di direktori.
Salin konten aplikasi Anda ke dalam src:
1. Jika sumbernya adalah file ZIP (termasuk file .jar), ekstrak konten ke dalam src.
2. Jika kode sumbernya adalah direktori, salin konten ke dalam src.
Jalankan gcloud builds submit . untuk membangun aplikasi Anda.

Inkompatibilitas umum

Buildpack yang mengandalkan variabel lingkungan yang diinjeksikan oleh Cloud Foundry seperti VCAP_SERVICES tidak akan berfungsi. Sebaiknya Anda secara eksplisit mendeklarasikan dependensi pada apa yang diinjeksikan Buildpack menggunakan sistem pengelolaan bahasa Anda.
Untuk mem-patch image yang dihasilkan dengan cara ini, Anda harus membangun ulang image menggunakan versi build dan image run terbaru. Image aplikasi tidak akan di-patch secara otomatis dengan memperbarui stemcell BOSH jika Anda menjalankannya di Cloud Foundry.
Build akan terjadi di lingkungan jaringan yang berbeda dengan cluster Cloud Foundry Anda. Anda mungkin harus menyiapkan kumpulan Cloud Build kustom dengan akses ke mirror paket internal Anda.

Langkah Berikutnya

Memigrasikan konfigurasi aplikasi