Sampel migrasi: Spring Music

Sampel migrasi ini menggunakan project Spring Music untuk menunjukkan cara aplikasi Cloud Foundry dapat dibangun sebagai image aplikasi yang mematuhi OSI. Sampel ini menggunakan strategi lift and shift, yang memakai komponen open source dari ekosistem Cloud Foundry. Setelah membuat image aplikasi, Anda perlu mengonfigurasi aplikasi tersebut untuk di-deploy ke Cloud Run.

Sebelum memulai

Pastikan Anda telah menyiapkan project baru untuk Cloud Run seperti yang dijelaskan di halaman setup.
Pastikan Anda memiliki REGISTRY_URI untuk menyimpan penampung. Cloud Run merekomendasikan penggunaan Artifact Registry.
Jika Anda dikenai kebijakan organisasi pembatasan domain yang membatasi pemanggilan yang tidak terautentikasi untuk project, Anda perlu mengakses layanan yang di-deploy seperti yang dijelaskan di bagian Menguji layanan pribadi.
Instal Docker di workstation Anda. Docker digunakan untuk membuat image menengah untuk membangun project.

Izin yang diperlukan untuk men-deploy

Untuk panduan ini, Anda memerlukan izin untuk membangun, menyimpan image container yang telah dibuat, dan men-deploy-nya.

Anda harus memiliki salah satu dari hal berikut:

Peran Project Owner
Peran Project Editor
Berikut adalah kumpulan peran tersebut:
- Peran Cloud Build Editor
- Peran Admin Artifact Registry
- Peran Admin Penyimpanan
- Peran Admin Cloud Run
- Peran Pengguna Akun Layanan

Struktur Project

Untuk panduan ini, sebaiknya buat direktori project, misalnya cr-spring-music/, dan buat subdirektori saat Anda mempelajari panduan ini.

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

Membuat Image build

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 container registry tempat Anda ingin memublikasikan image build.

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 container registry tempat Anda ingin memublikasikan image build

Membangun Spring Music untuk Cloud Foundry

Untuk meng-clone project Spring Music dan menjalankan perintah build seolah-olah kita men-deploy project ke Cloud Foundry:

Clone repositori Spring Music:

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

Untuk tujuan panduan ini, kita akan menggunakan versi lama aplikasi Spring Music yang menggunakan Java 8 dan Spring Boot 2. Untuk melakukannya, kita akan beralih ke revisi project Spring Music lama:
```
git checkout 610ba471a643a20dee7a62d88a7879f13a21d6a3
```
Pindahkan ke repositori:
```
cd spring-music
```
Buat biner Spring Music:
```
./gradlew clean assemble
```

Anda sekarang memiliki folder build/ dengan aplikasi Spring Music yang dikompilasi dan siap untuk dikirim ke instance Cloud Foundry.

Konversi Spring Music menjadi aplikasi yang kompatibel dengan Cloud Run

Anda harus mengambil output perintah build guna menyiapkan artefak Spring Music untuk di-deploy ke Cloud Run.

Buat direktori staging cr-app dan sub-direktori src di dalamnya:
```
mkdir -p cr-app/src
```
Tirukan cf push dengan mengekstrak konten JAR yang dikompilasi ke dalam direktori src:
```
unzip build/libs/spring-music-1.0.jar -d cr-app/src
```
Ubah direktori menjadi cr-app/:
```
cd cr-app/
```
Buat file baru dengan nama Dockerfile. Dockerfile ini akan menggunakan image build dan image runtime yang dibuat pada langkah sebelumnya untuk membuat image aplikasi yang dapat dijalankan untuk Spring Music, menggunakan buildpack Java.

Tempel kode berikut ke dalam 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

Membangun Spring Music sebagai image yang sesuai dengan OCI

Pada langkah ini, Anda akan menginstruksikan Cloud Build cara membuat image yang sesuai dengan OCI menggunakan image build, image runtime, dan Dockerfile aplikasi yang dibuat pada langkah sebelumnya.

Untuk membuat image yang sesuai dengan OCI:

Buat file dengan nama cloudbuild.yaml. Ini adalah konfigurasi build yang akan menginstruksikan Cloud Build cara mem-build aplikasi.

Tempel konfigurasi berikut ke dalam 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

Ganti REGISTRY_URI dengan URI container registry tempat Anda memublikasikan builder dan runner.

Build image aplikasi menggunakan Cloud Build:
```
gcloud builds submit .
```
Saat build selesai, catat URI image yang dihasilkan. Anda akan membutuhkannya saat men-deploy aplikasi di langkah berikutnya. Image yang dihasilkan akan berupa image container yang sesuai dengan OCI untuk menjalankan aplikasi Spring Music, yang di-build menggunakan komponen Cloud Foundry open source.

Men-deploy ke Cloud Run

Anda harus membuat file definisi layanan untuk digunakan di Cloud Run:

Buat akun layanan untuk aplikasi Anda:

gcloud iam service-accounts create spring-music

Buat file service.yaml dengan kode berikut:

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

Ganti PROJECT_NUMBER dengan nomor project Anda.
Ganti SPRING_IMAGE_URI dengan URI image aplikasi yang dibuat di bagian membangun Spring Music sebagai image yang sesuai dengan OCI.

Men-deploy layanan ke Cloud Run:
```
gcloud run services replace service.yaml
```
Setelah deployment selesai, Anda dapat membuka aplikasi Spring Music yang sedang berjalan di URL yang di-deploy.

Langkah Berikutnya

Untuk pembahasan lebih mendalam tentang proses containerization, lihat Bermigrasi ke container OCI.