Beispielmigration: Spring Music

Diese Beispielmigration verwendet das Spring Music-Projekt, das zeigt, wie eine Cloud Foundry-Anwendung als OCI-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.

Hinweis

  • 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 die folgenden Rollen:

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 Ausführungs-Image mit cflinux3 als Basis-Image erstellt. Das Build-Image wird als Build-Umgebung zum Erstellen des Anwendungs-Images verwendet.

  1. Erstellen Sie in diesem Verzeichnis das Verzeichnis build/ und darin cd:

    mkdir build && cd build
    
  2. 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
    
  3. Cloud Build zum Erstellen und Veröffentlichen des builder-Images verwenden

    gcloud builds \
        submit --tag "REGISTRY_URI/builder: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/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.

  1. Erstellen Sie ein Verzeichnis namens run/ und darin cd:

    mkdir run && cd run
    
  2. 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
    
  3. 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={}
    
  4. 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:

  1. Klonen Sie das Repository Spring Music:

    git clone https://github.com/cloudfoundry-samples/spring-music.git
    
  2. Für diese Anleitung verwenden wir eine ältere Version der Spring Music-Anwendung, die Java 8 und Spring Boot 2 nutzt. Dazu wechseln wir zu einer älteren Version des Spring Music-Projekts:

    git checkout 610ba471a643a20dee7a62d88a7879f13a21d6a3
    
  3. Wechseln Sie zum Repository:

    cd spring-music
    
  4. Erstellen Sie das Spring Music-Binärprogramm:

    ./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.

  1. Erstellen Sie das Staging-Verzeichnis cr-app und darin ein src-Unterverzeichnis:

    mkdir -p cr-app/src
    
  2. 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
    
  3. Ändern Sie das Verzeichnis in cr-app/:

    cd cr-app/
    
  4. 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.

  5. 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-kompatibles 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:

  1. 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.

  2. 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.
  3. Erstellen Sie das Anwendungs-Image mit Cloud Build:

    gcloud builds submit .
    

    Notieren Sie sich nach Abschluss des Builds den URI des resultierenden Images. 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 für die Verwendung in Cloud Run erstellen:

  1. Erstellen Sie ein Dienstkonto für Ihre Anwendung:

    gcloud iam service-accounts create spring-music
    
  2. 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
    
  3. 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