Beispielmigration: Spring Music

Diese Beispielmigration zeigt mit dem Projekt Spring Music, wie eine Cloud Foundry-Anwendung als OOC-konformes Anwendungs-Image erstellt werden kann. In diesem Beispiel wird die Lift-and-Shift-Strategie verwendet, die Open-Source-Komponenten aus der Cloud Foundry-Umgebung verwendet. Nachdem Sie das Anwendungs-Image erstellt haben, müssen Sie die Anwendung für die Bereitstellung in Cloud Run konfigurieren.

Hinweise

Prüfen Sie, ob Sie ein neues Projekt für Cloud Run eingerichtet haben, wie auf der Seite Einrichtung beschrieben.
Sie benötigen einen REGISTRY_URI zum Speichern von Containern. Cloud Run empfiehlt die Verwendung von Artifact Registry.
Wenn Sie einer Domaineinschränkung zur Organisation nicht eingeschränkter Aufrufe für Ihr Projekt unterliegen, müssen Sie auf Ihren bereitgestellten Dienst zugreifen, wie unter Private Dienste testen beschrieben.
Installieren Sie Docker auf Ihrer Workstation. Docker wird zum Erstellen von Zwischen-Images verwendet, um das Projekt zu erstellen.

Für das Deployment erforderliche Berechtigungen

Für diese Anleitung benötigen Sie Berechtigungen zum Erstellen, Speichern des erstellten Container-Images und Bereitstellen.

Sie benötigen EINES von Folgendem:

Rolle Projektinhaber
Rolle Projektbearbeiter
Die folgenden Rollen:
- Rolle „Cloud Build-Bearbeiter“
- Rolle „Artifact Registry-Administrator“
- Rolle "Storage-Administrator"
- Rolle „Cloud Run-Administrator“
- Rolle "Dienstkontonutzer"

Projektstruktur

Für diese Anleitung empfehlen wir die Erstellung eines Projektverzeichnisses wie cr-spring-music/ und Unterverzeichnissen, während Sie die Anleitung durcharbeiten.

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

Build-Image erstellen

In diesem Abschnitt wird ein Build-Image mit cflinux3 als Basis-Image erstellt. Das Build-Image wird als Build-Umgebung zum Erstellen des Anwendungs-Images verwendet.

Erstellen Sie in diesem Verzeichnis das Verzeichnis build/ und darin cd:
```
mkdir build && cd build
```

Erstellen Sie im Ordner build/ eine neue Datei mit dem Namen Dockerfile und fügen Sie den folgenden Code ein:

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

Cloud Build zum Erstellen und Veröffentlichen des builder-Images verwenden
```
gcloud builds \
    submit --tag "REGISTRY_URI/builder:stable"
```
Ersetzen Sie dabei REGISTRY_URI durch die Adresse der Artifact Registry, in der Sie das Build-Image veröffentlichen möchten. Beispiel: REGION-docker.pkg.dev/PROJECT_ID/REPOSITORY/builder:stable.

Laufzeit-Image erstellen

In diesem Abschnitt wird ein Ausführungs-Image mit cflinux3 als Basis-Image erstellt. Das Ausführungs-Image wird als Basis-Image verwendet, wenn Sie das endgültige Anwendungs-Image erstellen.

Erstellen Sie ein Verzeichnis namens run/ und darin cd:
```
mkdir run && cd run
```

Erstellen Sie im Ordner run/ ein neues Shell-Skript namens entrypoint.bash mit folgendem Code:

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

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

Erstellen Sie im Ordner run/ eine neue Datei mit dem Namen Dockerfile und fügen Sie den folgenden Code ein:

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

Verwenden Sie Cloud Build, um das runtime-Image zu erstellen und zu veröffentlichen:
```
gcloud builds submit \
    --tag "REGISTRY_URI/runtime:stable"
```
Ersetzen Sie REGISTRY_URI durch die Adresse der Artifact Registry, in der Sie das Build-Image veröffentlichen möchten. Beispiel: REGION-docker.pkg.dev/PROJECT_ID/REPOSITORY/runtime:stable.

Spring Music für Cloud Foundry erstellen

Klonen Sie das Projekt Spring Music und führen Sie die Build-Befehle so aus, als ob Sie das Projekt in Cloud Foundry bereitstellen würden:

Klonen Sie das Repository Spring Music:

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

Für diese Anleitung verwenden wir eine ältere Version der Spring Music-Anwendung, die Java 8 und Spring Boot 2 verwendet. Dazu wechseln wir zu einer älteren Überarbeitung des Spring Music-Projekts:
```
git checkout 610ba471a643a20dee7a62d88a7879f13a21d6a3
```
Wechseln Sie zum Repository:
```
cd spring-music
```
Erstellen Sie die Spring Music-Binärdatei:
```
./gradlew clean assemble
```

Sie haben jetzt einen build/-Ordner mit der kompilierten Spring Music-Anwendung, der in eine Cloud Foundry-Instanz übertragen werden kann.

Spring Music in eine Cloud Run-kompatible Anwendung konvertieren

Sie müssen die Ausgabe des Build-Befehls verwenden, um das Spring Music-Artefakt für die Bereitstellung in Cloud Run vorzubereiten.

Erstellen Sie das Staging-Verzeichnis cr-app und darin ein src-Unterverzeichnis:
```
mkdir -p cr-app/src
```
Migrieren Sie cf push, indem Sie den Inhalt der kompilierten JAR-Datei in das Verzeichnis src extrahieren:
```
unzip build/libs/spring-music-1.0.jar -d cr-app/src
```
Ändern Sie das Verzeichnis in cr-app/:
```
cd cr-app/
```
Erstellen Sie eine neue Datei mit dem Namen Dockerfile: Dieses Dockerfile verwendet das Build-Image und das Laufzeit-Image, die in den vorherigen Schritten erstellt wurden, um das ausführbare Anwendungs-Image für Spring Music mit dem Java-Buildpack zu erstellen.

Fügen Sie den folgenden Code in das Dockerfile ein:

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

Spring Music als OCI-konformes Image erstellen

In diesem Schritt erteilen Sie Cloud Build Anweisungen zum Erstellen eines OCI-kompatiblen Images mit dem Build-Image, Laufzeit-Image und dem Anwendungs-Dockerfile, das in den vorherigen Schritten erstellt wurde.

So erstellen Sie das OCI-kompatible Image:

Erstellen Sie eine Datei mit dem Namen cloudbuild.yaml. Dies ist eine Build-Konfiguration, mit der Cloud Build Anweisungen zum Erstellen der Anwendung erhält.

Fügen Sie die folgende Konfiguration in cloudbuild.yaml ein:

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

Ersetzen Sie REGISTRY_URI durch den URI der Container Registry, in der Sie den Builder und den Runner veröffentlicht haben.

Erstellen Sie das Anwendungs-Image mit Cloud Build:
```
gcloud builds submit .
```
Notieren Sie sich nach Abschluss des Builds den resultierenden Image-URI. Sie benötigen ihn bei der Bereitstellung der Anwendung in den nächsten Schritten. Das resultierende Image ist ein OCI-kompatibles Container-Image zum Ausführen der Spring Music-Anwendung, die mit Open-Source-Komponenten von Cloud Foundry erstellt wurde.

In Cloud Run bereitstellen

Sie müssen eine Dienstdefinitionsdatei zur Verwendung in Cloud Run erstellen:

Erstellen Sie ein Dienstkonto für Ihre Anwendung:
```
gcloud iam service-accounts create spring-music
```

Erstellen Sie eine service.yaml-Datei mit folgendem Code:

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

Ersetzen Sie PROJECT_NUMBER durch die Projekt-ID.
Ersetzen Sie SPRING_IMAGE_URI durch den URI des Anwendungs-Images, das unter Spring Music als OCI-konformes Image erstellen erstellt wurde.

Stellen Sie den Dienst in Cloud Run bereit:
```
gcloud run services replace service.yaml
```
Nach Abschluss der Bereitstellung können Sie die ausgeführte Spring Music-Anwendung unter der bereitgestellten URL aufrufen.

Weitere Informationen

Ausführliche Informationen zum Containerisierungsprozess finden Sie unter Zu OCI-Containern migrieren.