ML-Vision-Analyselösung mit Dataflow und der Cloud Vision API bereitstellen

Last reviewed 2024-05-16 UTC

In diesem Bereitstellungsdokument wird beschrieben, wie Sie eine Dataflow-Pipeline bereitstellen, um Bilddateien im großen Umfang mit der Cloud Vision API zu verarbeiten. In dieser Pipeline werden die Ergebnisse der verarbeiteten Dateien in BigQuery gespeichert. Sie können die Dateien zu Analysezwecken oder zum Trainieren von BigQuery ML-Modellen verwenden.

Die Dataflow-Pipeline, die Sie bei dieser Bereitstellung erstellen, kann Millionen von Bildern pro Tag verarbeiten. Die einzige Einschränkung ist Ihr Vision API-Kontingent. Sie können Ihr Vision API-Kontingent basierend auf Ihren Skalierungsanforderungen erhöhen.

Diese Anleitung richtet sich an Data Engineers und Data Scientists. In diesem Dokument wird davon ausgegangen, dass Sie Grundkenntnisse in der Erstellung von Dataflow-Pipelines mit dem Java SDK von Apache Beam, GoogleSQL für BigQuery und grundlegenden Shell-Scripts haben. Außerdem wird davon ausgegangen, dass Sie mit der Vision API vertraut sind.

Architektur

Das folgende Diagramm veranschaulicht den Systemablauf beim Erstellen einer Lösung für die ML-gestützte Bildanalyse.

Eine Architektur, die den Informationsfluss bei Aufnahme und Trigger, Verarbeitung, Speicherung und Analyse von Prozessen zeigt.

Im vorherigen Diagramm fließen Informationen so durch die Architektur:

  1. Ein Client lädt Bilddateien in einen Cloud Storage-Bucket hoch.
  2. Cloud Storage sendet eine Nachricht über den Datenupload an Pub/Sub.
  3. Pub/Sub benachrichtigt Dataflow über den Upload.
  4. Die Dataflow-Pipeline sendet die Bilder an die Vision API.
  5. Die Vision API verarbeitet die Bilder und gibt dann die Anmerkungen zurück.
  6. Die Pipeline sendet die annotierten Dateien zur Analyse an BigQuery.

Lernziele

  • Erstellen Sie eine Apache Beam-Pipeline für die Bildanalyse der in Cloud Storage geladenen Bilder.
  • Verwenden Sie Dataflow Runner v2, um die Apache Beam-Pipeline im Streamingmodus auszuführen, um die Bilder direkt nach dem Hochladen zu analysieren.
  • Mit der Vision API Bilder für eine Reihe von Feature-Typen analysieren
  • Anmerkungen mit BigQuery analysieren

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.

Nach Abschluss des Erstellens der Beispielanwendung können Sie weitere Kosten vermeiden, indem Sie die erstellten Ressourcen löschen. Weitere Informationen finden Sie unter Bereinigen.

Hinweise

  1. Sign in to your Google Cloud account. If you're new to Google Cloud, create an account to evaluate how our products perform in real-world scenarios. New customers also get $300 in free credits to run, test, and deploy workloads.

  2. In the Google Cloud console, on the project selector page, select or create a Google Cloud project.

    Go to project selector

  3. Make sure that billing is enabled for your Google Cloud project.

  4. In the Google Cloud console, on the project selector page, select or create a Google Cloud project.

    Go to project selector

  5. Make sure that billing is enabled for your Google Cloud project.

  6. In the Google Cloud console, activate Cloud Shell.

    Activate Cloud Shell

    At the bottom of the Google Cloud console, a Cloud Shell session starts and displays a command-line prompt. Cloud Shell is a shell environment with the Google Cloud CLI already installed and with values already set for your current project. It can take a few seconds for the session to initialize.

  7. Klonen Sie das GitHub-Repository, das den Quellcode der Dataflow-Pipeline enthält: 
        git clone
    https://github.com/GoogleCloudPlatform/dataflow-vision-analytics.git
  8. Wechseln Sie zum Stammverzeichnis des Repositorys:
        cd dataflow-vision-analytics
  9. Folgen Sie der Anleitung im Abschnitt Einstieg des dataflow-vision-analytics-Repositorys auf GitHub, um die folgenden Aufgaben auszuführen:
    • Mehrere APIs aktivieren
    • Cloud Storage-Bucket erstellen
    • Pub/Sub-Thema und -Abo erstellen.
    • BigQuery-Dataset erstellen
    • Richten Sie mehrere Umgebungsvariablen für diese Bereitstellung ein.

Dataflow-Pipeline für alle implementierten Vision API-Features ausführen

Die Dataflow-Pipeline fordert eine bestimmte Reihe von Vision API-Features und ‑Attributen in den annotierten Dateien an und verarbeitet sie.

Die in der folgenden Tabelle aufgeführten Parameter gelten nur für die Dataflow-Pipeline in dieser Bereitstellung. Eine vollständige Liste der standardmäßigen Dataflow-Ausführungsparameter finden Sie unter Dataflow-Pipelineoptionen festlegen.

Parametername Beschreibung

batchSize

Die Anzahl der Bilder, die in einer Anfrage an die Vision API enthalten sein sollen. Der Standardwert ist 1. Sie können ihn auf maximal 16 erhöhen.

datasetName

Der Name des BigQuery-Ausgabe-Datasets.

features

Eine Liste von Features zur Bildverarbeitung. Die Pipeline unterstützt die Funktionen „Label“, „Sehenswürdigkeit“, „Logo“, „Gesicht“, „Zuschnittshinweis“ und „Bildeigenschaften“.

keyRange

Der Parameter, der die maximale Anzahl paralleler Aufrufe der Vision API definiert. Der Standardwert ist 1.

labelAnnottationTable,
landmarkAnnotationTable,
logoAnnotationTable,
faceAnnotationTable,
imagePropertiesTable,
cropHintAnnotationTable,
errorLogTable

Stringparameter mit Tabellennamen für verschiedene Annotationen. Die Standardwerte werden für jede Tabelle angegeben, z. B. label_annotation.

maxBatchCompletionDurationInSecs

Die Zeit, die gewartet werden soll, bevor Bilder verarbeitet werden, wenn ein unvollständiger Bildersatz vorhanden ist. Der Standardwert ist 30 Sekunden.

subscriberId

Die ID des Pub/Sub-Abos, das Cloud Storage-Eingabebenachrichtigungen empfängt.

visionApiProjectId

Die Projekt-ID, die für die Vision API verwendet werden soll.

  1. Führen Sie in Cloud Shell den folgenden Befehl aus, um Bilder für alle von der Dataflow-Pipeline unterstützten Featuretypen zu verarbeiten:

    ./gradlew run --args=" \
--jobName=test-vision-analytics \
  --streaming \
  --runner=DataflowRunner \
  --enableStreamingEngine \
  --diskSizeGb=30 \
  --project=${PROJECT} \
  --datasetName=${BIGQUERY_DATASET} \
  --subscriberId=projects/${PROJECT}/subscriptions/${GCS_NOTIFICATION_SUBSCRIPTION} \
  --visionApiProjectId=${PROJECT} \
  --features=IMAGE_PROPERTIES,LABEL_DETECTION,LANDMARK_DETECTION,LOGO_DETECTION,CROP_HINTS,FACE_DETECTION"

    Das spezielle Dienstkonto muss Lesezugriff auf den Bucket haben, der die Bilder enthält. Mit anderen Worten: Dem Konto muss die Rolle roles/storage.objectViewer für diesen Bucket zugewiesen sein.

    Weitere Informationen zur Verwendung eines speziellen Dienstkontos finden Sie unter Sicherheit und Berechtigungen in Dataflow.

  2. Öffnen Sie die angezeigte URL in einem neuen Browsertab oder rufen Sie die Seite Dataflow-Jobs auf und wählen Sie die Pipeline test-vision-analytics aus.

    Nach einigen Sekunden wird die Grafik für den Dataflow-Job angezeigt:

    Workflow-Diagramm für den Dataflow-Job

    Die Dataflow-Pipeline wird jetzt ausgeführt und wartet darauf, Eingabebenachrichtigungen vom Pub/Sub-Abo zu erhalten.

  3. Lösen Sie die Dataflow-Bildverarbeitung aus, indem Sie die sechs Beispieldateien in den Eingabe-Bucket hochladen:

    gcloud storage cp data-sample/* gs://${IMAGE_BUCKET}

  4. Suchen Sie in der Google Cloud Console den Bereich „Benutzerdefinierte Zähler“ und prüfen Sie die benutzerdefinierten Zähler in Dataflow. Prüfen Sie auch, ob alle sechs Bilder in Dataflow verarbeitet wurden. Mit der Filterfunktion des Steuerfelds können Sie die gewünschten Messwerte aufrufen. Wenn Sie nur die Zähler anzeigen lassen möchten, die mit dem Präfix numberOf beginnen, geben Sie numberOf in den Filter ein.

    Liste der Zähler, die so gefiltert ist, dass nur Zähler angezeigt werden, die mit „numberof“ beginnen.

  5. Prüfen Sie in Cloud Shell, ob die Tabellen automatisch erstellt wurden:

    bq query --nouse_legacy_sql "SELECT table_name FROM ${BIGQUERY_DATASET}.INFORMATION_SCHEMA.TABLES ORDER BY table_name"

    Die Ausgabe sieht so aus:

    +----------------------+
|      table_name      |
+----------------------+
| crop_hint_annotation |
| face_annotation      |
| image_properties     |
| label_annotation     |
| landmark_annotation  |
| logo_annotation      |
+----------------------+

  6. Sehen Sie sich das Schema für die Tabelle landmark_annotation an. Das LANDMARK_DETECTION-Feature erfasst die vom API-Aufruf zurückgegebenen Attribute.

    bq show --schema --format=prettyjson ${BIGQUERY_DATASET}.landmark_annotation

    Die Ausgabe sieht so aus:

    [
   {
      "name":"gcs_uri",
      "type":"STRING"
   },
   {
      "name":"feature_type",
      "type":"STRING"
   },
   {
      "name":"transaction_timestamp",
      "type":"STRING"
   },
   {
      "name":"mid",
      "type":"STRING"
   },
   {
      "name":"description",
      "type":"STRING"
   },
   {
      "name":"score",
      "type":"FLOAT"
   },
   {
      "fields":[
         {
            "fields":[
               {
                  "name":"x",
                  "type":"INTEGER"
               },
               {
              "name":"y",
              "type":"INTEGER"
           }
        ],
        "mode":"REPEATED",
        "name":"vertices",
        "type":"RECORD"
     }
  ],
  "name":"boundingPoly",
  "type":"RECORD"
},
{
  "fields":[
     {
        "fields":[
           {
              "name":"latitude",
              "type":"FLOAT"
           },
           {
              "name":"longitude",
              "type":"FLOAT"
           }
        ],
            "name":"latLon",
            "type":"RECORD"
          }
        ],
      "mode":"REPEATED",
      "name":"locations",
      "type":"RECORD"
   }
]

  7. Führen Sie die folgenden bq query-Befehle aus, um die von der API erstellten Anmerkungsdaten aufzurufen. Sie sehen dann alle in diesen sechs Bildern gefundenen Markierungen, sortiert nach der Wahrscheinlichkeitsbewertung:

    bq query --nouse_legacy_sql "SELECT SPLIT(gcs_uri, '/')[OFFSET(3)] file_name, description, score, locations FROM ${BIGQUERY_DATASET}.landmark_annotation ORDER BY score DESC"

    Die Ausgabe sieht in etwa so aus:

    +------------------+-------------------+------------+---------------------------------+
|    file_name     |    description    |   score    |            locations            |
+------------------+-------------------+------------+---------------------------------+
| eiffel_tower.jpg | Eiffel Tower      |  0.7251996 | ["POINT(2.2944813 48.8583701)"] |
| eiffel_tower.jpg | Trocadéro Gardens | 0.69601923 | ["POINT(2.2892823 48.8615963)"] |
| eiffel_tower.jpg | Champ De Mars     |  0.6800974 | ["POINT(2.2986304 48.8556475)"] |
+------------------+-------------------+------------+---------------------------------+

    Ausführliche Beschreibungen aller Spalten, die speziell für Anmerkungen gelten, finden Sie unter AnnotateImageResponse.

  8. Führen Sie den folgenden Befehl aus, um die Streaming-Pipeline zu beenden. Die Pipeline wird weiter ausgeführt, auch wenn keine weiteren Pub/Sub-Benachrichtigungen zur Verarbeitung vorhanden sind.

      gcloud dataflow jobs cancel
    --region ${REGION} $(gcloud dataflow jobs list
    --region ${REGION} --filter="NAME:test-vision-analytics AND STATE:Running"
    --format="get(JOB_ID)")

    Im folgenden Abschnitt finden Sie weitere Beispielabfragen, mit denen verschiedene Bildmerkmale der Bilder analysiert werden.

Flickr30K-Dataset analysieren

In diesem Abschnitt erkennen Sie Labels und Sehenswürdigkeiten im öffentlichen Flickr30k-Bilddatensatz, der auf Kaggle gehostet wird.

  1. Ändern Sie in Cloud Shell die Parameter der Dataflow-Pipeline, damit sie für ein großes Dataset optimiert ist. Erhöhen Sie auch die Werte für batchSize und keyRange, um einen höheren Durchsatz zu ermöglichen. Dataflow skaliert die Anzahl der Worker nach Bedarf:

    ./gradlew run --args=" \
  --runner=DataflowRunner \
  --jobName=vision-analytics-flickr \
  --streaming \
  --enableStreamingEngine \
  --diskSizeGb=30 \
  --autoscalingAlgorithm=THROUGHPUT_BASED \
  --maxNumWorkers=5 \
  --project=${PROJECT} \
  --region=${REGION} \
  --subscriberId=projects/${PROJECT}/subscriptions/${GCS_NOTIFICATION_SUBSCRIPTION} \
  --visionApiProjectId=${PROJECT} \
  --features=LABEL_DETECTION,LANDMARK_DETECTION \
  --datasetName=${BIGQUERY_DATASET} \
  --batchSize=16 \
  --keyRange=5"

    Da der Datensatz groß ist, können Sie die Bilder nicht mit Cloud Shell von Kaggle abrufen und an den Cloud Storage-Bucket senden. Dazu müssen Sie eine VM mit einer größeren Laufwerkgröße verwenden.

  2. Wenn Sie Kaggle-basierte Bilder abrufen und an den Cloud Storage-Bucket senden möchten, folgen Sie der Anleitung im Abschnitt Hochladen von Bildern in den Storage-Bucket simulieren im GitHub-Repository.

  3. Wenn Sie den Fortschritt des Kopiervorgangs anhand der benutzerdefinierten Messwerte in der Dataflow-Benutzeroberfläche beobachten möchten, rufen Sie die Seite Dataflow-Jobs auf und wählen Sie die Pipeline vision-analytics-flickr aus. Die Kundenzähler sollten sich regelmäßig ändern, bis die Dataflow-Pipeline alle Dateien verarbeitet hat.

    Die Ausgabe ähnelt dem folgenden Screenshot des Bereichs „Benutzerdefinierte Zähler“. Eine der Dateien im Datensatz hat den falschen Typ. Das wird durch den Zähler rejectedFiles angezeigt. Diese Zählerwerte sind ungefähre Angaben. Möglicherweise sind die Werte höher. Außerdem ändert sich die Anzahl der Anmerkungen aufgrund der höheren Genauigkeit der Verarbeitung durch die Vision API höchstwahrscheinlich.

    Liste der Zähler, die mit der Verarbeitung der Kaggle-basierten Bilder verknüpft sind.

    Auf der Seite mit den Kontingenten für die Vision API sehen Sie, ob Sie die verfügbaren Ressourcen erreichen oder überschreiten.

    In unserem Beispiel hat die Dataflow-Pipeline nur etwa 50% ihres Kontingents genutzt. Je nachdem, wie viel Prozent des Kontingents Sie nutzen, können Sie die Parallelität der Pipeline erhöhen, indem Sie den Wert des Parameters keyRange erhöhen.

  4. Beenden Sie die Pipeline:

    gcloud dataflow jobs list --region $REGION --filter="NAME:vision-analytics-flickr AND STATE:Running" --format="get(JOB_ID)"

Anmerkungen in BigQuery analysieren

Bei dieser Bereitstellung haben Sie mehr als 30.000 Bilder für die Anmerkung von Labels und Sehenswürdigkeiten verarbeitet. In diesem Abschnitt erfassen Sie Statistiken zu diesen Dateien. Sie können diese Abfragen im GoogleSQL for BigQuery-Arbeitsbereich oder mit dem bq-Befehlszeilentool ausführen.

Die angezeigten Zahlen können von den Beispielabfrageergebnissen in dieser Bereitstellung abweichen. Die Vision API verbessert kontinuierlich die Genauigkeit ihrer Analyse. Sie kann bessere Ergebnisse liefern, wenn Sie dasselbe Bild nach dem ersten Test der Lösung analysieren.

  1. Rufen Sie in der Google Cloud Console die Seite BigQuery-Abfrageeditor auf und führen Sie den folgenden Befehl aus, um die 20 wichtigsten Labels im Datensatz aufzurufen:

    Zum Abfrageeditor

    SELECT  description, count(*)ascount \
  FROM vision_analytics.label_annotation
  GROUP BY description ORDER BY count DESC LIMIT 20

    Die Ausgabe sieht in etwa so aus:

    +------------------+-------+
|   description    | count |
+------------------+-------+
| Leisure          |  7663 |
| Plant            |  6858 |
| Event            |  6044 |
| Sky              |  6016 |
| Tree             |  5610 |
| Fun              |  5008 |
| Grass            |  4279 |
| Recreation       |  4176 |
| Shorts           |  3765 |
| Happy            |  3494 |
| Wheel            |  3372 |
| Tire             |  3371 |
| Water            |  3344 |
| Vehicle          |  3068 |
| People in nature |  2962 |
| Gesture          |  2909 |
| Sports equipment |  2861 |
| Building         |  2824 |
| T-shirt          |  2728 |
| Wood             |  2606 |
+------------------+-------+

  2. Sie können ermitteln, welche anderen Labels in einem Bild mit einem bestimmten Label vorhanden sind, sortiert nach Häufigkeit:

    DECLARE label STRING DEFAULT 'Plucked string instruments';

WITH other_labels AS (
   SELECT description, COUNT(*) count
FROM vision_analytics.label_annotation
WHERE gcs_uri IN (
    SELECT gcs_uri FROM vision_analytics.label_annotation WHERE description = label )
  AND description != label
GROUP BY description)
SELECT description, count, RANK() OVER (ORDER BY count DESC) rank
FROM other_labels ORDER BY rank LIMIT 20;

    Die Ausgabe sieht so aus: Für das im vorherigen Befehl verwendete Label Zupfinstrumente sollte Folgendes angezeigt werden:

    +------------------------------+-------+------+
|         description          | count | rank |
+------------------------------+-------+------+
| String instrument            |   397 |    1 |
| Musical instrument           |   236 |    2 |
| Musician                     |   207 |    3 |
| Guitar                       |   168 |    4 |
| Guitar accessory             |   135 |    5 |
| String instrument accessory  |    99 |    6 |
| Music                        |    88 |    7 |
| Musical instrument accessory |    72 |    8 |
| Guitarist                    |    72 |    8 |
| Microphone                   |    52 |   10 |
| Folk instrument              |    44 |   11 |
| Violin family                |    28 |   12 |
| Hat                          |    23 |   13 |
| Entertainment                |    22 |   14 |
| Band plays                   |    21 |   15 |
| Jeans                        |    17 |   16 |
| Plant                        |    16 |   17 |
| Public address system        |    16 |   17 |
| Artist                       |    16 |   17 |
| Leisure                      |    14 |   20 |
+------------------------------+-------+------+

  3. Die zehn häufigsten erkannten Markierungen ansehen:

      SELECT description, COUNT(description) AS count
  FROM vision_analytics.landmark_annotation
  GROUP BY description ORDER BY count DESC LIMIT 10

    Die Ausgabe sieht so aus:

      +--------------------+-------+
  |    description     | count |
  +--------------------+-------+
  | Times Square       |    55 |
  | Rockefeller Center |    21 |
  | St. Mark's Square  |    16 |
  | Bryant Park        |    13 |
  | Millennium Park    |    13 |
  | Ponte Vecchio      |    13 |
  | Tuileries Garden   |    13 |
  | Central Park       |    12 |
  | Starbucks          |    12 |
  | National Mall      |    11 |
  +--------------------+-------+

  4. Ermitteln Sie die Bilder, die am ehesten Wasserfälle enthalten:

    SELECT SPLIT(gcs_uri, '/')[OFFSET(3)] file_name, description, score
FROM vision_analytics.landmark_annotation
WHERE LOWER(description) LIKE '%fall%'
ORDER BY score DESC LIMIT 10

    Die Ausgabe sieht so aus:

    +----------------+----------------------------+-----------+
|   file_name    |        description         |   score    |
+----------------+----------------------------+-----------+
| 895502702.jpg  | Waterfall Carispaccha      |  0.6181358 |
| 3639105305.jpg | Sahalie Falls Viewpoint    | 0.44379658 |
| 3672309620.jpg | Gullfoss Falls             | 0.41680416 |
| 2452686995.jpg | Wahclella Falls            | 0.39005348 |
| 2452686995.jpg | Wahclella Falls            |  0.3792498 |
| 3484649669.jpg | Kodiveri Waterfalls        | 0.35024035 |
| 539801139.jpg  | Mallela Thirtham Waterfall | 0.29260656 |
| 3639105305.jpg | Sahalie Falls              |  0.2807213 |
| 3050114829.jpg | Kawasan Falls              | 0.27511594 |
| 4707103760.jpg | Niagara Falls              | 0.18691841 |
+----------------+----------------------------+-----------+

  5. Suchen Sie nach Bildern von Sehenswürdigkeiten in einem Umkreis von drei Kilometern vom Kolosseum in Rom (die Funktion ST_GEOPOINT verwendet den Längengrad und den Breitengrad des Kolosseums):

    WITH
  landmarksWithDistances AS (
  SELECT
    gcs_uri,
    description,
    location,
    ST_DISTANCE(location,
      ST_GEOGPOINT(12.492231,
        41.890222)) distance_in_meters,
  FROM
    `vision_analytics.landmark_annotation` landmarks
  CROSS JOIN
    UNNEST(landmarks.locations) AS location )
SELECT
  SPLIT(gcs_uri,"/")[OFFSET(3)] file,
  description,
    ROUND(distance_in_meters) distance_in_meters,
  location,
  CONCAT("https://storage.cloud.google.com/", SUBSTR(gcs_uri, 6)) AS image_url
FROM
  landmarksWithDistances
WHERE
  distance_in_meters < 3000
ORDER BY
  distance_in_meters
LIMIT
  100

    Wenn Sie die Abfrage ausführen, sehen Sie, dass es mehrere Bilder des Kolosseums gibt, aber auch Bilder des Konstantinsbogens, des Palatins und einer Reihe anderer häufig fotografierter Orte.

    Sie können die Daten in BigQuery Geo Viz visualisieren, indem Sie die vorherige Abfrage einfügen. Wählen Sie einen Punkt auf der Karte aus, um die Details dazu zu sehen. Das Attribut Image_url enthält einen Link zur Bilddatei.

    Karte mit Standorten und der Entfernung vom Kolosseum.

Hinweis zu Abfrageergebnissen Standortinformationen sind normalerweise für Sehenswürdigkeiten vorhanden. Ein Bild kann mehrere Standorte derselben Sehenswürdigkeit enthalten. Diese Funktion wird im Typ AnnotateImageResponse beschrieben.

Da ein Standort die Position der Szene im Bild angeben kann, können mehrere LocationInfo-Elemente vorhanden sein. Mit einem anderen Ort kann angegeben werden, wo das Bild aufgenommen wurde.

Bereinigen

Damit Ihrem Google Cloud-Konto die in diesem Leitfaden verwendeten Ressourcen nicht in Rechnung gestellt werden, können Sie entweder das Projekt löschen, das die Ressourcen enthält, oder das Projekt beibehalten und die einzelnen Ressourcen löschen.

Google Cloud-Projekt löschen

Am einfachsten können Sie die Abrechnung deaktivieren, wenn Sie das Google Cloud-Projekt löschen, das Sie für die Anleitung erstellt haben.

  1. In the Google Cloud console, go to the Manage resources page.

    Go to Manage resources

  2. In the project list, select the project that you want to delete, and then click Delete.
  3. In the dialog, type the project ID, and then click Shut down to delete the project.

Wenn Sie Ressourcen einzeln löschen möchten, folgen Sie der Anleitung im Abschnitt Bereinigen des GitHub-Repositories.

Nächste Schritte

Beitragende

Autoren:

Weitere Beitragende: