Anleitung für Systempakete

In dieser Anleitung erfahren Sie, wie Sie einen benutzerdefinierten Cloud Run-Dienst erstellen, der einen Eingabeparameter für die Diagrammbeschreibung in ein Diagramm im PNG-Bildformat transformiert. Dabei kommt Graphviz zum Einsatz. Diese Software wird in der Containerumgebung des Dienstes als Systempaket installiert. Graphviz wird dann über Befehlszeilendienstprogramme zum Verarbeiten von Anfragen verwendet.

Ziele

Mit einem Dockerfile einen benutzerdefinierten Container schreiben und erstellen
Cloud Run-Dienst schreiben, erstellen und bereitstellen
Mit dem Graphviz dot-Dienstprogramm Diagramme generieren
Dienst testen, indem Sie ein DOT-Syntaxdiagramm aus der Sammlung oder ein eigens erstelltes Diagramm veröffentlichen

Kosten

In diesem Dokument verwenden Sie die folgenden kostenpflichtigen Komponenten von Google Cloud:

Mit dem Preisrechner können Sie eine Kostenschätzung für Ihre voraussichtliche Nutzung vornehmen. Neuen Google Cloud-Nutzern steht möglicherweise eine kostenlose Testversion zur Verfügung.

Hinweise

Melden Sie sich bei Ihrem Google Cloud-Konto an. Wenn Sie mit Google Cloud noch nicht vertraut sind, erstellen Sie ein Konto, um die Leistungsfähigkeit unserer Produkte in der Praxis sehen und bewerten zu können. Neukunden erhalten außerdem ein Guthaben von 300 $, um Arbeitslasten auszuführen, zu testen und bereitzustellen.

Wählen Sie in der Google Cloud Console auf der Seite der Projektauswahl ein Google Cloud-Projekt aus oder erstellen Sie eines.

Zur Projektauswahl

Die Abrechnung für das Google Cloud-Projekt muss aktiviert sein.

Wählen Sie in der Google Cloud Console auf der Seite der Projektauswahl ein Google Cloud-Projekt aus oder erstellen Sie eines.

Zur Projektauswahl

Die Abrechnung für das Google Cloud-Projekt muss aktiviert sein.

Aktivieren Sie die Cloud Run Admin API.
Installieren und initialisieren Sie die gcloud CLI.
Aktualisieren Sie die Komponenten:
```
gcloud components update
```

Erforderliche Rollen

Bitten Sie Ihren Administrator, Ihnen die folgenden IAM-Rollen für Ihr Projekt zuzuweisen, um die Berechtigungen zu erhalten, die Sie zum Ausführen der Anleitung benötigen:

Cloud Build-Bearbeiter (roles/cloudbuild.builds.editor)
Cloud Run-Administrator (roles/run.admin)
Dienstkonten erstellen (roles/iam.serviceAccountCreator)
Service Account User (roles/iam.serviceAccountUser)
Service Usage Consumer (roles/serviceusage.serviceUsageConsumer)
Storage-Administrator (roles/storage.admin)

Weitere Informationen zum Zuweisen von Rollen finden Sie unter Zugriff verwalten.

Sie können die erforderlichen Berechtigungen auch über benutzerdefinierte Rollen oder andere vordefinierte Rollen erhalten.

gcloud-Standardeinstellungen einrichten

So konfigurieren Sie gcloud mit Standardeinstellungen für den Cloud Run-Dienst:

Legen Sie ein Standardprojekt fest:
```
gcloud config set project PROJECT_ID
```
Ersetzen Sie PROJECT_ID durch den Namen des Projekts, das Sie für diese Anleitung erstellt haben.
Konfigurieren Sie gcloud für die von Ihnen ausgewählte Region:
```
gcloud config set run/region REGION
```
Ersetzen Sie REGION durch die unterstützte Cloud Run-Region Ihrer Wahl.

Cloud Run-Standorte

Cloud Run ist regional. Die Infrastruktur, in der die Cloud Run-Dienste ausgeführt werden, befindet sich demnach in einer bestimmten Region. Aufgrund der Verwaltung durch Google sind die Anwendungen in allen Zonen innerhalb dieser Region redundant verfügbar.

Bei der Auswahl der Region, in der Ihre Cloud Run-Dienste ausgeführt werden, ist vorrangig, dass die Anforderungen hinsichtlich Latenz, Verfügbarkeit oder Langlebigkeit erfüllt werden. Sie können im Allgemeinen die Region auswählen, die Ihren Nutzern am nächsten liegt, aber Sie sollten den Standort der anderen Google Cloud-Produkte berücksichtigen, die von Ihrem Cloud Run-Dienst verwendet werden. Die gemeinsame Nutzung von Google Cloud-Produkten an mehreren Standorten kann sich auf die Latenz und die Kosten des Dienstes auswirken.

Cloud Run ist in diesen Regionen verfügbar:

Unterliegt Preisstufe 1

asia-east1 (Taiwan)
asia-northeast1 (Tokio)
asia-northeast2 (Osaka)
europe-north1 (Finnland) Niedriger CO₂-Wert
europe-southwest1 (Madrid)
europe-west1 (Belgien) Niedriger CO₂-Ausstoß
europe-west4 (Niederlande)
europe-west8 (Mailand)
europe-west9 (Paris) Niedriger CO₂-Ausstoß
me-west1 (Tel Aviv)
us-central1 (Iowa) Niedriger CO₂-Ausstoß
us-east1 (South Carolina)
us-east4 (Northern Virginia)
us-east5 (Columbus)
us-south1 (Dallas)
us-west1 (Oregon) Niedriger CO₂-Ausstoß

Unterliegt Preisstufe 2

africa-south1 (Johannesburg)
asia-east2 (Hongkong)
asia-northeast3 (Seoul, Südkorea)
asia-southeast1 (Singapur)
asia-southeast2 (Jakarta)
asia-south1 (Mumbai, Indien)
asia-south2 (Delhi, Indien)
australia-southeast1 (Sydney)
australia-southeast2 (Melbourne)
europe-central2 (Warschau, Polen)
europe-west10 (Berlin)
europe-west12 (Turin)
europe-west2 (London, Vereinigtes Königreich) Niedriger CO₂-Ausstoß
europe-west3 (Frankfurt, Deutschland) Niedriger CO₂-Wert
europe-west6 (Zürich, Schweiz) Niedriger CO₂-Ausstoß
me-central1 (Doha)
me-central2 (Dammam)
northamerica-northeast1 (Montreal) Niedriger CO₂-Ausstoß
northamerica-northeast2 (Toronto) Niedriger CO₂-Ausstoß
southamerica-east1 (Sao Paulo, Brasilien) Niedriger CO₂-Ausstoß
southamerica-west1 (Santiago, Chile) Niedriger CO₂-Ausstoß
us-west2 (Los Angeles)
us-west3 (Salt Lake City)
us-west4 (Las Vegas)

Wenn Sie bereits einen Cloud Run-Dienst erstellt haben, können Sie dessen Region im Cloud Run-Dashboard der Google Cloud Console aufrufen.

Codebeispiel abrufen

So rufen Sie das gewünschte Codebeispiel ab:

Klonen Sie das Repository der Beispiel-App auf Ihren lokalen Computer:
Node.js
```
git clone https://github.com/GoogleCloudPlatform/nodejs-docs-samples.git
```
Sie können auch das Beispiel als ZIP-Datei herunterladen und extrahieren.
Python
```
git clone https://github.com/GoogleCloudPlatform/python-docs-samples.git
```
Sie können auch das Beispiel als ZIP-Datei herunterladen und extrahieren.
Einfach loslegen (Go)
```
git clone https://github.com/GoogleCloudPlatform/golang-samples.git
```
Sie können auch das Beispiel als ZIP-Datei herunterladen und extrahieren.
Java
```
git clone https://github.com/GoogleCloudPlatform/java-docs-samples.git
```
Sie können auch das Beispiel als ZIP-Datei herunterladen und extrahieren.

Wechseln Sie in das Verzeichnis, das den Cloud Run-Beispielcode enthält:

Node.js

cd nodejs-docs-samples/run/system-package/

Python

cd python-docs-samples/run/system-package/

Einfach loslegen (Go)

cd golang-samples/run/system_package/

Java

cd java-docs-samples/run/system-package/

Architektur visualisieren

Die grundlegende Architektur sieht so aus:

Diagramm, das den Anfragefluss vom Nutzer zum Webdienst und vom Webdienst zum Graphviz-DOT-Dienstprogramm zeigt — Die Diagrammquelle finden Sie in der DOT-Beschreibung.

Der Nutzer stellt eine HTTP-Anfrage an den Cloud Run-Dienst, der ein Graphviz-Dienstprogramm ausführt, um die Anfrage in ein Bild zu transformieren. Dieses Bild wird an den Nutzer als die HTTP-Antwort auf seine Anfrage gesendet.

Code verstehen

Umgebungskonfiguration mit dem `Dockerfile` definieren

Ihr Dockerfile ist spezifisch für die Sprache und die grundlegende Betriebsumgebung, z. B. Ubuntu, die Ihr Dienst verwenden wird.

In der Kurzanleitung "Erstellen und Bereitstellen" lernen Sie verschiedene Dockerfiles kennen, auf deren Basis ein Dockerfile für andere Dienste erstellt werden kann.

Für diesen Dienst sind ein oder mehrere zusätzliche Systempakete erforderlich, die standardmäßig nicht verfügbar sind.

Öffnen Sie die Dockerfile in einem Editor.
Suchen Sie nach der Anweisung Dockerfile RUN. Mit dieser Anweisung können Sie beliebige Shell-Befehle ausführen, um die Umgebung zu verändern. Wenn das Dockerfile über mehrere Phasen verfügt, also mehrere FROM-Anweisungen aufweist, finden Sie die Anweisung in der letzten Phase.

Es hängt von dem im Container angegebenen Betriebssystem ab, welche spezifischen Pakete erforderlich sind und mit welchem Mechanismus diese installiert werden.

Klicken Sie auf den entsprechenden Tab, um Anweisungen für Ihr Betriebssystem oder Basis-Image zu erhalten.
Debian/Ubuntu
```
RUN apt-get update -y && apt-get install -y \
  graphviz \
  && apt-get clean
```
Alpine
Alpine erfordert ein zweites Paket zur Unterstützung von Schriftarten.
```
RUN apk --no-cache add graphviz ttf-ubuntu-font-family
```
Wenn Sie das Betriebssystem Ihres Container-Images ermitteln möchten, sehen Sie nach, welcher Name in der FROM-Anweisung oder in einer README-Datei für Ihr Basis-Image verwendet wird. Wenn Sie beispielsweise von node erweitern, finden Sie die Dokumentation und das übergeordnete Element Dockerfile auf Docker Hub.
Testen Sie Ihre Anpassung, indem Sie das Image erstellen. Verwenden Sie dazu lokal docker build oder Cloud Build.

Eingehende Anfragen verarbeiten

Der Beispieldienst verwendet Parameter aus der eingegangenen HTTP-Anfrage, um einen Systemaufruf durchzuführen, damit der entsprechende Befehl des dot-Dienstprogramms ausgeführt wird.

Im folgenden HTTP-Handler wird aus der dot-Abfragestringvariable ein Eingabeparameter für die Diagrammbeschreibung extrahiert.

Diagrammbeschreibungen können Zeichen enthalten, die für die Verwendung in einem Abfragestring URL-codiert sein müssen.

Node.js

app.get('/diagram.png', (req, res) => {
  try {
    const image = createDiagram(req.query.dot);
    res.setHeader('Content-Type', 'image/png');
    res.setHeader('Content-Length', image.length);
    res.setHeader('Cache-Control', 'public, max-age=86400');
    res.send(image);
  } catch (err) {
    console.error(`error: ${err.message}`);
    const errDetails = (err.stderr || err.message).toString();
    if (errDetails.includes('syntax')) {
      res.status(400).send(`Bad Request: ${err.message}`);
    } else {
      res.status(500).send('Internal Server Error');
    }
  }
});

Python

@app.route("/diagram.png", methods=["GET"])
def index():
    """Takes an HTTP GET request with query param dot and
    returns a png with the rendered DOT diagram in a HTTP response.
    """
    try:
        image = create_diagram(request.args.get("dot"))
        response = make_response(image)
        response.headers.set("Content-Type", "image/png")
        return response

    except Exception as e:
        print(f"error: {e}")

        # If no graphviz definition or bad graphviz def, return 400
        if "syntax" in str(e):
            return f"Bad Request: {e}", 400

        return "Internal Server Error", 500

Einfach loslegen (Go)


// diagramHandler renders a diagram using HTTP request parameters and the dot command.
func diagramHandler(w http.ResponseWriter, r *http.Request) {
	if r.Method != http.MethodGet {
		log.Printf("method not allowed: %s", r.Method)
		http.Error(w, fmt.Sprintf("HTTP Method %s Not Allowed", r.Method), http.StatusMethodNotAllowed)
		return
	}

	q := r.URL.Query()
	dot := q.Get("dot")
	if dot == "" {
		log.Print("no graphviz definition provided")
		http.Error(w, "Bad Request", http.StatusBadRequest)
		return
	}

	// Cache header must be set before writing a response.
	w.Header().Set("Cache-Control", "public, max-age=86400")

	input := strings.NewReader(dot)
	if err := createDiagram(w, input); err != nil {
		log.Printf("createDiagram: %v", err)
		// Do not cache error responses.
		w.Header().Del("Cache-Control")
		if strings.Contains(err.Error(), "syntax") {
			http.Error(w, "Bad Request: DOT syntax error", http.StatusBadRequest)
		} else {
			http.Error(w, "Internal Server Error", http.StatusInternalServerError)
		}
	}
}

Java

get(
    "/diagram.png",
    (req, res) -> {
      InputStream image = null;
      try {
        String dot = req.queryParams("dot");
        image = createDiagram(dot);
        res.header("Content-Type", "image/png");
        res.header("Content-Length", Integer.toString(image.available()));
        res.header("Cache-Control", "public, max-age=86400");
      } catch (Exception e) {
        if (e.getMessage().contains("syntax")) {
          res.status(400);
          return String.format("Bad Request: %s", e.getMessage());
        } else {
          res.status(500);
          return "Internal Server Error";
        }
      }
      return image;
    });

Es muss zwischen internen Serverfehlern und ungültigen Nutzereingaben unterschieden werden. Der Beispieldienst gibt für alle dot-Befehlszeilenfehler einen internen Serverfehler zurück, außer wenn die Fehlermeldung den String syntax enthält, was auf ein Problem mit der Nutzereingabe hinweist.

Diagramm generieren

Die Kernlogik der Diagrammgenerierung verwendet das dot-Befehlszeilentool, um den Eingabeparameter für die Diagrammbeschreibung zu einem Diagramm im PNG-Bildformat zu verarbeiten.

Node.js

// Generate a diagram based on a graphviz DOT diagram description.
const createDiagram = dot => {
  if (!dot) {
    throw new Error('syntax: no graphviz definition provided');
  }

  // Adds a watermark to the dot graphic.
  const dotFlags = [
    '-Glabel="Made on Cloud Run"',
    '-Gfontsize=10',
    '-Glabeljust=right',
    '-Glabelloc=bottom',
    '-Gfontcolor=gray',
  ].join(' ');

  const image = execSync(`/usr/bin/dot ${dotFlags} -Tpng`, {
    input: dot,
  });
  return image;
};

Python

def create_diagram(dot):
    """Generates a diagram based on a graphviz DOT diagram description.

    Args:
        dot: diagram description in graphviz DOT syntax

    Returns:
        A diagram in the PNG image format.
    """
    if not dot:
        raise Exception("syntax: no graphviz definition provided")

    dot_args = [  # These args add a watermark to the dot graphic.
        "-Glabel=Made on Cloud Run",
        "-Gfontsize=10",
        "-Glabeljust=right",
        "-Glabelloc=bottom",
        "-Gfontcolor=gray",
        "-Tpng",
    ]

    # Uses local `dot` binary from Graphviz:
    # https://graphviz.gitlab.io
    image = subprocess.run(
        ["dot"] + dot_args, input=dot.encode("utf-8"), stdout=subprocess.PIPE
    ).stdout

    if not image:
        raise Exception("syntax: bad graphviz definition provided")
    return image

Einfach loslegen (Go)


// createDiagram generates a diagram image from the provided io.Reader written to the io.Writer.
func createDiagram(w io.Writer, r io.Reader) error {
	stderr := new(bytes.Buffer)
	args := []string{
		"-Glabel=Made on Cloud Run",
		"-Gfontsize=10",
		"-Glabeljust=right",
		"-Glabelloc=bottom",
		"-Gfontcolor=gray",
		"-Tpng",
	}
	cmd := exec.Command("/usr/bin/dot", args...)
	cmd.Stdin = r
	cmd.Stdout = w
	cmd.Stderr = stderr

	if err := cmd.Run(); err != nil {
		return fmt.Errorf("exec(%s) failed (%w): %s", cmd.Path, err, stderr.String())
	}

	return nil
}

Java

// Generate a diagram based on a graphviz DOT diagram description.
public static InputStream createDiagram(String dot) {
  if (dot == null || dot.isEmpty()) {
    throw new NullPointerException("syntax: no graphviz definition provided");
  }
  // Adds a watermark to the dot graphic.
  List<String> args = new ArrayList<>();
  args.add("/usr/bin/dot");
  args.add("-Glabel=\"Made on Cloud Run\"");
  args.add("-Gfontsize=10");
  args.add("-Glabeljust=right");
  args.add("-Glabelloc=bottom");
  args.add("-Gfontcolor=gray");
  args.add("-Tpng");

  StringBuilder output = new StringBuilder();
  InputStream stdout = null;
  try {
    ProcessBuilder pb = new ProcessBuilder(args);
    Process process = pb.start();
    OutputStream stdin = process.getOutputStream();
    stdout = process.getInputStream();
    // The Graphviz dot program reads from stdin.
    Writer writer = new OutputStreamWriter(stdin, "UTF-8");
    writer.write(dot);
    writer.close();
    process.waitFor();
  } catch (Exception e) {
    System.out.println(e);
  }
  return stdout;
}

Sicheren Dienst entwerfen

Alle eventuell bestehenden Sicherheitslücken im dot-Tool sind potenzielle Sicherheitslücken im Webdienst. Sie können dies umgehen, indem Sie aktuelle Versionen des graphviz-Pakets verwenden und das Container-Image regelmäßig neu erstellen.

Wenn Sie das aktuelle Beispiel so erweitern möchten, dass als Befehlszeilenparameter auch Nutzereingaben zulässig sind, sollten Sie gewisse Vorsichtsmaßnahmen treffen, um Angriffe durch Befehlsinjektion zu vermeiden. Auf folgende Arten können Injektionsangriffe beispielsweise verhindert werden:

Zuordnen von Eingaben zu den Einträgen eines Wörterbuchs unterstützter Parameter
Validierungseingaben entsprechen einer Reihe als sicher eingestufter Werte, möglicherweise unter Verwendung regulärer Ausdrücke
Maskieren von Eingaben, damit Shell-Syntax nicht ausgewertet wird

Sie können potenzielle Sicherheitslücken weiter eindämmen, indem Sie den Dienst mit einem Dienstkonto bereitstellen, dem keine Berechtigungen für die Nutzung von Google Cloud-Diensten erteilt wurden, anstatt das Standardkonto zu verwenden, das über gängige Berechtigungen verfügt. Aus diesem Grund wird in den Schritten in dieser Anleitung ein neues Dienstkonto erstellt und verwendet.

Code versenden

Um Ihren Code zu senden, erstellen Sie ihn mit Cloud Build, laden ihn in Container Registry hoch und stellen ihn in Cloud Run bereit:

Führen Sie den folgenden Befehl aus, um den Container zu erstellen und ihn in Container Registry zu veröffentlichen:
Node.js
```
gcloud builds submit --tag gcr.io/PROJECT_ID/graphviz
```
Dabei ist PROJECT_ID Ihre Google-Cloud-Projekt-ID und graphviz der Name, den Sie dem Dienst geben möchten.

Bei Erfolg wird eine SUCCESS-Meldung mit der ID, Erstellungszeit und dem Image-Namen angezeigt. Das Image wird in Container Registry gespeichert und kann bei Bedarf wiederverwendet werden.
Python
```
gcloud builds submit --tag gcr.io/PROJECT_ID/graphviz
```
Dabei ist PROJECT_ID Ihre Google-Cloud-Projekt-ID und graphviz der Name, den Sie dem Dienst geben möchten.

Bei Erfolg wird eine SUCCESS-Meldung mit der ID, Erstellungszeit und dem Image-Namen angezeigt. Das Image wird in Container Registry gespeichert und kann bei Bedarf wiederverwendet werden.
Einfach loslegen (Go)
```
gcloud builds submit --tag gcr.io/PROJECT_ID/graphviz
```
Dabei ist PROJECT_ID Ihre Google-Cloud-Projekt-ID und graphviz der Name, den Sie dem Dienst geben möchten.

Bei Erfolg wird eine SUCCESS-Meldung mit der ID, Erstellungszeit und dem Image-Namen angezeigt. Das Image wird in Container Registry gespeichert und kann bei Bedarf wiederverwendet werden.
Java
In diesem Beispiel wird Jib verwendet, um Docker-Images mit gängigen Java-Tools zu erstellen. Jib optimiert Container-Builds, ohne dass ein Dockerfile erforderlich ist oder Docker installiert sein muss. Weitere Informationen zum Erstellen von Java-Containern mit Jib
1. Konfigurieren und erstellen Sie mit dem Dockerfile ein Basis-Image mit den installierten Systempaketen, um das Standard-Basis-Image von Jib zu überschreiben:
  # Use the Official eclipse-temurin image for a lean production stage of our multi-stage build. # https://hub.docker.com/_/eclipse-temurin/ FROM eclipse-temurin:17.0.10_7-jre RUN apt-get update -y && apt-get install -y \ graphviz \ && apt-get clean
```
gcloud builds submit --tag gcr.io/PROJECT_ID/graphviz-base
```
  Dabei ist PROJECT_ID Ihre Google Cloud-Projekt-ID.
2. Verwenden Sie das gcloud Credential Helper, um Docker für das Übertragen per Push in Ihre Container Registry zu autorisieren.
```
gcloud auth configure-docker
```
3. Erstellen Sie Ihren endgültigen Container mit Jib und veröffentlichen Sie ihn in Container Registry:
  <plugin> <groupId>com.google.cloud.tools</groupId> <artifactId>jib-maven-plugin</artifactId> <version>3.4.0</version> <configuration> <from> <image>gcr.io/PROJECT_ID/graphviz-base</image> </from> <to> <image>gcr.io/PROJECT_ID/graphviz</image> </to> </configuration> </plugin>
```
mvn compile jib:build \
 -Dimage=gcr.io/PROJECT_ID/graphviz \
 -Djib.from.image=gcr.io/PROJECT_ID/graphviz-base
```
  Dabei ist PROJECT_ID Ihre Google Cloud-Projekt-ID.
Stellen Sie es so bereit:
Befehlszeile
1. Erstellen Sie ein neues Dienstkonto. Ihr Code, einschließlich aller verwendeten Systempakete, kann nur die Google Cloud-Dienste verwenden, die diesem Dienstkonto zugewiesen wurden.
```
gcloud iam service-accounts create SA_NAME
```
  Dabei ist SA_NAME der Name, den Sie diesem Dienstkonto geben. Wenn Ihr Code einen Fehler oder eine Sicherheitslücke enthält, kann er nicht auf Ihre anderen Google Cloud-Projektressourcen zugreifen.
2. Stellen Sie den Code bereit und geben Sie das Dienstkonto an.
```
gcloud run deploy graphviz-web --service-account SA_NAME@PROJECT_ID.iam.gserviceaccount.com  --image gcr.io/PROJECT_ID/graphviz
```
  Dabei ist PROJECT_ID Ihre Google Cloud-Projekt-ID, SA_NAME der Name des von Ihnen erstellten Dienstkontos, graphviz der Name des oben aufgeführten Containers und graphviz-web der Name des Dienstes. Antworten Sie mit Y auf die Eingabeaufforderung „Nicht authentifiziert zulassen“. Informationen zur IAM-basierten Authentifizierung finden Sie unter Zugriff verwalten.
3. Warten Sie, bis die Bereitstellung abgeschlossen ist. Dies kann etwa eine halbe Minute dauern. Bei Erfolg wird in der Befehlszeile die Dienst-URL angezeigt.
Terraform

Informationen zum Anwenden oder Entfernen einer Terraform-Konfiguration finden Sie unter Grundlegende Terraform-Befehle.

Mit dem folgenden Terraform-Code wird ein Cloud Run-Dienst erstellt.
```
resource "google_service_account" "graphviz" {
  account_id   = "graphviz"
  display_name = "GraphViz Tutorial Service Account"
}

resource "google_cloud_run_v2_service" "default" {
  name     = "graphviz-example"
  location = "us-central1"

  template {
    containers {
      # Replace with the URL of your graphviz image
      #   gcr.io/<YOUR_GCP_PROJECT_ID>/graphviz
      image = "us-docker.pkg.dev/cloudrun/container/hello"
    }

    service_account = google_service_account.graphviz.email
  }
}
```
Ersetzen Sie gcr.io/cloudrun/hello durch einen Verweis auf Ihren Container.

Mit dem folgenden Terraform-Code wird Ihr Cloud Run-Dienst öffentlich.
```
# Make Cloud Run service publicly accessible
resource "google_cloud_run_service_iam_member" "allow_unauthenticated" {
  service  = google_cloud_run_v2_service.default.name
  location = google_cloud_run_v2_service.default.location
  role     = "roles/run.invoker"
  member   = "allUsers"
}
```
Wenn Sie eine Codeaktualisierung für den Dienst bereitstellen möchten, wiederholen Sie die vorherigen Schritte. Bei jeder Bereitstellung für einen Dienst wird eine neue Version erstellt und der Traffic wird automatisch verarbeitet, sobald der Dienst bereit ist.

Testen

Testen Sie den Dienst. Dazu senden Sie in der Anfragenutzlast HTTP-POST-Anfragen mit DOT-Syntaxbeschreibungen.

Senden Sie eine HTTP-Anfrage an den Dienst.

Kopieren Sie folgende URL in die URL-Zeile Ihres Browsers und aktualisieren Sie [SERVICE_DOMAIN]:

https://SERVICE_DOMAIN/diagram.png?dot=digraph Run { rankdir=LR Code -> Build -> Deploy -> Run }

Sie können das Diagramm in eine Webseite einbetten:

<img src="https://SERVICE_DOMAIN/diagram.png?dot=digraph Run { rankdir=LR Code -> Build -> Deploy -> Run }" />

Öffnen Sie die ausgegebene diagram.png-Datei in einer Anwendung, die PNG-Dateien unterstützt, beispielsweise Chrome.

Sie sollte so aussehen:

Quelle: DOT-Beschreibung

Sie können sich eine kleine Sammlung von vorgefertigten Diagrammbeschreibungen ansehen.

Kopieren Sie den Inhalt der ausgewählten .dot-Datei
Senden Sie eine HTTP-Anfrage an den Dienst.

Kopieren Sie die URL in die URL-Zeile Ihres Browsers.
```
https://SERVICE_DOMAIN/diagram.png?dot=SELECTED DOTFILE CONTENTS
```

Bereinigen

Wenn Sie ein neues Projekt für diese Anleitung erstellt haben, löschen Sie das Projekt. Wenn Sie ein vorhandenes Projekt verwendet haben und es beibehalten möchten, ohne die Änderungen in dieser Anleitung hinzuzufügen, löschen Sie die für die Anleitung erstellten Ressourcen.

Projekt löschen

Am einfachsten vermeiden Sie weitere Kosten, wenn Sie das zum Ausführen der Anleitung erstellte Projekt löschen.

So löschen Sie das Projekt:

Achtung: Das Löschen von Projekten hat folgende Auswirkungen:

Alle Inhalte des Projekts werden gelöscht. Wenn Sie für die Aufgaben in diesem Dokument ein bereits bestehendes Projekt verwendet haben und dieses löschen, werden auch alle anderen im Rahmen des Projekts erstellten Daten gelöscht.
Benutzerdefinierte Projekt-IDs gehen verloren. Beim Erstellen dieses Projekts haben Sie möglicherweise eine benutzerdefinierte Projekt-ID erstellt, die Sie weiterhin verwenden möchten. Damit die URLs, die die Projekt-ID nutzen, z. B. eine appspot.com-URL, erhalten bleiben, sollten Sie ausgewählte Ressourcen innerhalb des Projekts löschen, statt das gesamte Projekt.

Wenn Sie mehrere Architekturen, Anleitungen und Kurzanleitungen durcharbeiten möchten, können Sie die Überschreitung von Projektkontingenten verhindern, indem Sie Projekte wiederverwenden.

Wechseln Sie in der Google Cloud Console zur Seite Ressourcen verwalten.
Zur Seite „Ressourcen verwalten“
Wählen Sie in der Projektliste das Projekt aus, das Sie löschen möchten, und klicken Sie dann auf Löschen.
Geben Sie im Dialogfeld die Projekt-ID ein und klicken Sie auf Shut down (Beenden), um das Projekt zu löschen.

Anleitungsressourcen löschen

Löschen Sie den Cloud Run-Dienst, den Sie in dieser Anleitung bereitgestellt haben:
```
gcloud run services delete SERVICE-NAME
```
Dabei ist SERVICE-NAME der von Ihnen ausgewählte Dienstname.

Sie können Cloud Run-Dienste auch über die Google Cloud Console löschen.
Entfernen Sie die Konfiguration der Standardregion gcloud, die Sie während der Einrichtung für die Anleitung hinzugefügt haben:
```
 gcloud config unset run/region
```
Entfernen Sie die Projektkonfiguration:
```
 gcloud config unset project
```
Löschen Sie sonstige Google Cloud-Ressourcen, die in dieser Anleitung erstellt wurden:
- Löschen Sie das Container-Image mit dem Namen gcr.io/<var>PROJECT_ID</var>/graphviz aus Container Registry.
- Löschen Sie das Dienstkonto <var>SA_NAME</var>.
```
gcloud iam service-accounts delete SA_NAME@PROJECT_ID.iam.gserviceaccount.com
```

Nächste Schritte

Experimentieren Sie mit der Graphviz-Anwendung:
- Sie können Unterstützung für andere Graphviz-Dienstprogramme hinzufügen, die andere Algorithmen für die Diagrammgenerierung verwenden.
- Sie können Diagramme in Cloud Storage speichern. Sie können sowohl das Bild als auch die DOT-Syntax speichern.
- Implementieren Sie mit der Cloud Natural Language API einen Schutz, um den Missbrauch von Inhalten zu verhindern.
- Ein weiteres Beispiel für ein Systempaket finden Sie in der Anleitung zur Verarbeitung von Images aus Cloud Storage.
Referenzarchitekturen, Diagramme und Best Practices zu Google Cloud kennenlernen. Weitere Informationen zu Cloud Architecture Center

Anleitung für Systempakete

Ziele

Kosten

Hinweise

Erforderliche Rollen

gcloud-Standardeinstellungen einrichten

Cloud Run-Standorte

Unterliegt Preisstufe 1

Unterliegt Preisstufe 2

Codebeispiel abrufen

Node.js

Python

Einfach loslegen (Go)

Java

Node.js

Python

Einfach loslegen (Go)

Java

Architektur visualisieren

Code verstehen

Umgebungskonfiguration mit dem Dockerfile definieren

Eingehende Anfragen verarbeiten

Node.js

Python

Einfach loslegen (Go)

Java

Diagramm generieren

Node.js

Python

Einfach loslegen (Go)

Java

Sicheren Dienst entwerfen

Code versenden

Node.js

Python

Einfach loslegen (Go)

Java

Befehlszeile

Terraform

Testen

Bereinigen

Projekt löschen

Anleitungsressourcen löschen

Nächste Schritte

Umgebungskonfiguration mit dem `Dockerfile` definieren