Chirp 2: Verbesserte mehrsprachige Genauigkeit

Chirp 2 ist die neueste Generation der mehrsprachigen ASR-spezifischen Modelle von Google. Sie wurde entwickelt, um die Anforderungen der Nutzer auf Grundlage von Feedback und Erfahrung zu erfüllen. Es ist genauer und schneller als das ursprüngliche Chirp-Modell und bietet wichtige neue Funktionen wie Zeitstempel auf Wortebene, Modellanpassung und Sprachübersetzung.

Colab-Notebook testen Notebook auf GitHub ansehen

Modelldetails

Chirp 2 ist ausschließlich in der Speech-to-Text API V2 verfügbar.

Modell-Kennzeichnungen

Sie können Chirp 2 wie jedes andere Modell verwenden, indem Sie bei Verwendung der API die entsprechende Modell-ID in Ihrer Erkennungsanfrage oder den Modellnamen in der Google Cloud -Konsole angeben.

Modell Modellkennung
Chirp 2 chirp_2

API-Methoden

Da Chirp 2 ausschließlich in der Speech-to-Text API V2 verfügbar ist, werden die folgenden Erkennungsmethoden unterstützt:

Modell Modellkennung Sprachunterstützung
V2 Speech.StreamingRecognize (gut für Streaming und Echtzeit-Audio) Eingeschränkt*
V2 Speech.Recognize (gut für kurze Audioaufnahmen < 1 Min.) Auf Augenhöhe mit Chirp
V2 Speech.BatchRecognize (gut für lange Audioaufnahmen 1 Min. bis 8 Stunden) Auf Augenhöhe mit Chirp

*Die aktuelle Liste der unterstützten Sprachen und Funktionen für jedes Transkriptionsmodell finden Sie in der Locations API.

Regionale Verfügbarkeit

Chirp 2 wird in den folgenden Regionen unterstützt:

Google Cloud Zone Einführungsreife
us-central1 GA
europe-west4 GA
asia-southeast1 Private Vorschau

Die aktuelle Liste der unterstützten Regionen, Sprachen und Funktionen von für jedes Transkriptionsmodell finden Sie mit der Standort-API, wie hier beschrieben.

Verfügbare Sprachen für die Transkription

Chirp 2 unterstützt die Transkription mit den Erkennungsmethoden StreamingRecognize, Recognize und BatchRecognize. Die Sprachunterstützung unterscheidet sich jedoch je nach verwendeter Methode. Insbesondere bietet BatchRecognize die umfangreichste Sprachunterstützung. StreamingRecognize unterstützt die folgenden Sprachen:

Sprache BCP-47-Code
Chinesisch, vereinfacht (China) cmn-Hans-CN
Chinese Traditional Taiwan cmn-hant-tw
Chinesisch, Kantonesisch (traditionell, Hongkong) yue-Hant-HK
Englisch (Australien) en-AU
Englisch (Indien) en-IN
Englisch (Vereinigtes Königreich) en-GB
Englisch (USA) en-US
Französisch (Kanada) fr-CA
Französisch (Frankreich) fr-FR
Deutsch (Deutschland) de-DE
Italienisch (Italien) it-IT
Japanisch (Japan) ja-JP
Portugiesisch (Brasilien) pt-BR
Spanisch (Spanien) es-ES
Spanisch (USA) es-US

Verfügbare Sprachen für die Übersetzung

Das sind die unterstützten Sprachen für die Sprachübersetzung. Die Sprachunterstützung für die Übersetzung in Chirp 2 ist nicht symmetrisch. Das bedeutet, dass wir zwar von Sprache A in Sprache B übersetzen können, die Übersetzung von Sprache B in Sprache A jedoch möglicherweise nicht verfügbar ist. Die folgenden Sprachpaare werden für die Sprachübersetzung unterstützt.

Für die Übersetzung ins Englische:

Ausgangs- -> Zielsprache Quelle -> Code der Zielsprache
Arabisch (Ägypten) -> Englisch ar-EG -> en-US
Arabisch (Golfregion) -> Englisch ar-x-gulf -> en-US
Arabisch (Levantinisch) -> Englisch ar-x-levant -> en-US
Arabisch (Maghreb) -> Englisch ar-x-maghrebi -> en-US
Katalanisch (Spanien) -> Englisch ca-ES -> en-US
Walisisch (Vereinigtes Königreich) -> Englisch cy-GB -> en-US
Deutsch (Deutschland) -> Englisch de-DE -> en-US
Spanisch (Lateinamerika) -> Englisch es-419 -> en-US
Spanisch (Spanien) -> Englisch es-ES -> en-US
Spanisch (USA) -> Englisch es-US -> en-US
Estnisch (Estland) -> Englisch et-EE -> en-US
Französisch (Kanada) -> Englisch fr-CA -> en-US
Französisch (Frankreich) -> Englisch fr-FR -> en-US
Persisch (Iran) -> Englisch fa-IR -> en-US
Indonesisch (Indonesien) -> Englisch id-ID -> en-US
Italienisch (Italien) -> Englisch it-IT -> en-US
Japanisch (Japan) -> Englisch ja-JP -> en-US
Lettisch (Lettland) -> Englisch lv-LV -> en-US
Mongolisch (Mongolei) -> Englisch mn-MN -> en-US
Niederländisch (Niederlande) -> Englisch nl-NL -> en-US
Portugiesisch (Brasilien) -> Englisch pt-BR -> en-US
Russisch (Russland) -> Englisch ru-RU -> en-US
Slowenisch (Slowenien) -> Englisch sl-SI -> en-US
Schwedisch (Schweden) -> Englisch sv-SE -> en-US
Tamil (Indien) -> Englisch ta-IN -> en-US
Türkisch (Türkei) -> Englisch tr-TR -> en-US
Chinesisch (vereinfacht, China) -> Englisch zh-Hans-CN -> en-US

Für die Übersetzung aus dem Englischen:

Ausgangs- -> Zielsprache Quelle -> Code der Zielsprache
Englisch -> Arabisch (Ägypten) en-US -> ar-EG
Englisch -> Arabisch (Golfregion) en-US -> ar-x-gulf
Englisch -> Arabisch (Levantinisch) en-US -> ar-x-levant
Englisch -> Arabisch (Maghreb) en-US -> ar-x-maghrebi
Englisch -> Katalanisch (Spanien) en-US -> ca-ES
Englisch –> Walisisch (Vereinigtes Königreich) en-US -> cy-GB
Englisch -> Deutsch (Deutschland) en-US -> de-DE
Englisch -> Estnisch (Estland) en-US -> et-EE
Englisch –> Persisch (Iran) en-US -> fa-IR
Englisch -> Indonesisch (Indonesien) en-US -> id-ID
Englisch -> Japanisch (Japan) en-US -> ja-JP
Englisch -> Lettisch (Lettland) en-US -> lv-LV
Englisch -> Mongolisch (Mongolei) en-US -> mn-MN
Englisch -> Slowenisch (Slowenien) en-US -> sl-SI
Englisch -> Schwedisch (Schweden) en-US -> sv-SE
Englisch -> Tamil (Indien) en-US -> ta-IN
Englisch -> Türkisch (Türkei) en-US -> tr-TR
Englisch -> Chinesisch (vereinfacht, China) en-US -> zh-Hans-CN

Funktionsunterstützung und Einschränkungen

Chirp 2 unterstützt die folgenden Funktionen:

Funktion Beschreibung
Automatische Zeichensetzung Wird automatisch vom Modell generiert und kann optional deaktiviert werden.
Automatische Großschreibung Wird automatisch vom Modell generiert und kann optional deaktiviert werden.
Sprachanpassung (Voreingenommenheit) Sie können dem Modell Hinweise in Form einfacher Wörter oder Wortgruppen geben, um die Erkennungsgenauigkeit für bestimmte Begriffe oder Eigennamen zu verbessern. Klassentokens oder benutzerdefinierte Klassen werden nicht unterstützt.
Zeitangaben für Wörter (Zeitstempel) Wird automatisch vom Modell generiert und kann optional aktiviert werden. Die Qualität und Geschwindigkeit der Transkription kann sich dadurch leicht verschlechtern.
Obszönitätenfilter Anstößige Wörter werden erkannt und im Transkript nur der erste Buchstabe gefolgt von Sternchen zurückgegeben (z. B. f***).
Sprachunabhängige Audiotranskription Das Modell leitet die gesprochene Sprache in Ihrer Audiodatei automatisch ab und transkribiert sie in der gängigsten Sprache.
Sprachspezifische Übersetzung Das Modell übersetzt automatisch aus der gesprochenen Sprache in die Zielsprache.
Erzwungene Normalisierung Wenn im Anfragetext definiert, führt die API Stringersetzungen für bestimmte Begriffe oder Wortgruppen aus, um für Einheitlichkeit bei der Transkription zu sorgen.
Konfidenzwerte auf Wortebene Die API gibt einen Wert zurück, es ist jedoch kein echter Konfidenzwert. Bei der Übersetzung werden keine Konfidenzwerte zurückgegeben.

Chirp 2 unterstützt die folgenden Funktionen nicht:

Funktion Beschreibung
Diarisierung Nicht unterstützt
Spracherkennung Nicht unterstützt

Mit Chirp 2 transkribieren

Hier erfahren Sie, wie Sie Chirp 2 für Transkriptionen und Übersetzungen verwenden.

Streamingspracherkennung ausführen

import os

from google.cloud.speech_v2 import SpeechClient
from google.cloud.speech_v2.types import cloud_speech
from google.api_core.client_options import ClientOptions

PROJECT_ID = os.getenv("GOOGLE_CLOUD_PROJECT")

def transcribe_streaming_chirp2(
    audio_file: str
) -> cloud_speech.StreamingRecognizeResponse:
    """Transcribes audio from audio file stream using the Chirp 2 model of Google Cloud Speech-to-Text V2 API.

    Args:
        audio_file (str): Path to the local audio file to be transcribed.
            Example: "resources/audio.wav"

    Returns:
        cloud_speech.RecognizeResponse: The response from the Speech-to-Text API V2 containing
        the transcription results.
    """

    # Instantiates a client
    client = SpeechClient(
        client_options=ClientOptions(
            api_endpoint="us-central1-speech.googleapis.com",
        )
    )

    # Reads a file as bytes
    with open(audio_file, "rb") as f:
        content = f.read()

    # In practice, stream should be a generator yielding chunks of audio data
    chunk_length = len(content) // 5
    stream = [
        content[start : start + chunk_length]
        for start in range(0, len(content), chunk_length)
    ]
    audio_requests = (
        cloud_speech.StreamingRecognizeRequest(audio=audio) for audio in stream
    )

    recognition_config = cloud_speech.RecognitionConfig(
        auto_decoding_config=cloud_speech.AutoDetectDecodingConfig(),
        language_codes=["en-US"],
        model="chirp_2",
    )
    streaming_config = cloud_speech.StreamingRecognitionConfig(
        config=recognition_config
    )
    config_request = cloud_speech.StreamingRecognizeRequest(
        recognizer=f"projects/{PROJECT_ID}/locations/us-central1/recognizers/_",
        streaming_config=streaming_config,
    )

    def requests(config: cloud_speech.RecognitionConfig, audio: list) -> list:
        yield config
        yield from audio

    # Transcribes the audio into text
    responses_iterator = client.streaming_recognize(
        requests=requests(config_request, audio_requests)
    )
    responses = []
    for response in responses_iterator:
        responses.append(response)
        for result in response.results:
            print(f"Transcript: {result.alternatives[0].transcript}")

    return responses

Synchrone Spracherkennung ausführen

import os

from google.cloud.speech_v2 import SpeechClient
from google.cloud.speech_v2.types import cloud_speech
from google.api_core.client_options import ClientOptions

PROJECT_ID = os.getenv("GOOGLE_CLOUD_PROJECT")

def transcribe_sync_chirp2(
    audio_file: str
) -> cloud_speech.RecognizeResponse:
    """Transcribes an audio file using the Chirp 2 model of Google Cloud Speech-to-Text V2 API.
    Args:
        audio_file (str): Path to the local audio file to be transcribed.
            Example: "resources/audio.wav"
    Returns:
        cloud_speech.RecognizeResponse: The response from the Speech-to-Text API containing
        the transcription results.
    """

    # Instantiates a client
    client = SpeechClient(
        client_options=ClientOptions(
            api_endpoint="us-central1-speech.googleapis.com",
        )
    )

    # Reads a file as bytes
    with open(audio_file, "rb") as f:
        audio_content = f.read()

    config = cloud_speech.RecognitionConfig(
        auto_decoding_config=cloud_speech.AutoDetectDecodingConfig(),
        language_codes=["en-US"],
        model="chirp_2",
    )

    request = cloud_speech.RecognizeRequest(
        recognizer=f"projects/{PROJECT_ID}/locations/us-central1/recognizers/_",
        config=config,
        content=audio_content,
    )

    # Transcribes the audio into text
    response = client.recognize(request=request)

    for result in response.results:
        print(f"Transcript: {result.alternatives[0].transcript}")

    return response

Batch-Spracherkennung ausführen

import os

from google.cloud.speech_v2 import SpeechClient
from google.cloud.speech_v2.types import cloud_speech
from google.api_core.client_options import ClientOptions

PROJECT_ID = os.getenv("GOOGLE_CLOUD_PROJECT")

def transcribe_batch_chirp2(
    audio_uri: str,
) -> cloud_speech.BatchRecognizeResults:
    """Transcribes an audio file from a Google Cloud Storage URI using the Chirp 2 model of Google Cloud Speech-to-Text V2 API.
    Args:
        audio_uri (str): The Google Cloud Storage URI of the input audio file.
            E.g., gs://[BUCKET]/[FILE]
    Returns:
        cloud_speech.RecognizeResponse: The response from the Speech-to-Text API containing
        the transcription results.
    """

    # Instantiates a client
    client = SpeechClient(
        client_options=ClientOptions(
            api_endpoint="us-central1-speech.googleapis.com",
        )
    )

    config = cloud_speech.RecognitionConfig(
        auto_decoding_config=cloud_speech.AutoDetectDecodingConfig(),
        language_codes=["en-US"],
        model="chirp_2",
    )

    file_metadata = cloud_speech.BatchRecognizeFileMetadata(uri=audio_uri)

    request = cloud_speech.BatchRecognizeRequest(
        recognizer=f"projects/{PROJECT_ID}/locations/us-central1/recognizers/_",
        config=config,
        files=[file_metadata],
        recognition_output_config=cloud_speech.RecognitionOutputConfig(
            inline_response_config=cloud_speech.InlineOutputConfig(),
        ),
    )

    # Transcribes the audio into text
    operation = client.batch_recognize(request=request)

    print("Waiting for operation to complete...")
    response = operation.result(timeout=120)

    for result in response.results[audio_uri].transcript.results:
        print(f"Transcript: {result.alternatives[0].transcript}")

    return response.results[audio_uri].transcript

Chirp 2-Funktionen verwenden

Hier finden Sie Codebeispiele, die zeigen, wie Sie die neuesten Funktionen verwenden können:

Sprachunabhängige Transkription ausführen

import os

from google.cloud.speech_v2 import SpeechClient
from google.cloud.speech_v2.types import cloud_speech
from google.api_core.client_options import ClientOptions

PROJECT_ID = os.getenv("GOOGLE_CLOUD_PROJECT")

def transcribe_sync_chirp2_auto_detect_language(
    audio_file: str
) -> cloud_speech.RecognizeResponse:
    """Transcribes an audio file and auto-detect spoken language using Chirp 2.
    Please see https://cloud.google.com/speech-to-text/v2/docs/encoding for more
    information on which audio encodings are supported.
    Args:
        audio_file (str): Path to the local audio file to be transcribed.
            Example: "resources/audio.wav"
    Returns:
        cloud_speech.RecognizeResponse: The response from the Speech-to-Text API containing
        the transcription results.
    """
    # Instantiates a client
    client = SpeechClient(
        client_options=ClientOptions(
            api_endpoint="us-central1-speech.googleapis.com",
        )
    )

    # Reads a file as bytes
    with open(audio_file, "rb") as f:
        audio_content = f.read()

    config = cloud_speech.RecognitionConfig(
        auto_decoding_config=cloud_speech.AutoDetectDecodingConfig(),
        language_codes=["auto"],  # Set language code to auto to detect language.
        model="chirp_2",
    )

    request = cloud_speech.RecognizeRequest(
        recognizer=f"projects/{PROJECT_ID}/locations/us-central1/recognizers/_",
        config=config,
        content=audio_content,
    )

    # Transcribes the audio into text
    response = client.recognize(request=request)

    for result in response.results:
        print(f"Transcript: {result.alternatives[0].transcript}")
        print(f"Detected Language: {result.language_code}")

    return response

Sprachübersetzung ausführen

import os

from google.cloud.speech_v2 import SpeechClient
from google.cloud.speech_v2.types import cloud_speech
from google.api_core.client_options import ClientOptions

PROJECT_ID = os.getenv("GOOGLE_CLOUD_PROJECT")

def translate_sync_chirp2(
    audio_file: str
) -> cloud_speech.RecognizeResponse:
    """Translates an audio file using Chirp 2.
    Args:
        audio_file (str): Path to the local audio file to be translated.
            Example: "resources/audio.wav"
    Returns:
        cloud_speech.RecognizeResponse: The response from the Speech-to-Text API containing
        the translated results.
    """

    # Instantiates a client
    client = SpeechClient(
        client_options=ClientOptions(
            api_endpoint="us-central1-speech.googleapis.com",
        )
    )

    # Reads a file as bytes
    with open(audio_file, "rb") as f:
        audio_content = f.read()

    config = cloud_speech.RecognitionConfig(
        auto_decoding_config=cloud_speech.AutoDetectDecodingConfig(),
        language_codes=["fr-FR"],  # Set language code to targeted to detect language.
        translation_config=cloud_speech.TranslationConfig(target_language="fr-FR"), # Set target language code.
        model="chirp_2",
    )

    request = cloud_speech.RecognizeRequest(
        recognizer=f"projects/{PROJECT_ID}/locations/us-central1/recognizers/_",
        config=config,
        content=audio_content,
    )

    # Transcribes the audio into text
    response = client.recognize(request=request)

    for result in response.results:
        print(f"Translated transcript: {result.alternatives[0].transcript}")

    return response

Zeitstempel auf Wortebene aktivieren

import os

from google.cloud.speech_v2 import SpeechClient
from google.cloud.speech_v2.types import cloud_speech
from google.api_core.client_options import ClientOptions

PROJECT_ID = os.getenv("GOOGLE_CLOUD_PROJECT")

def transcribe_sync_chirp2_with_timestamps(
    audio_file: str
) -> cloud_speech.RecognizeResponse:
    """Transcribes an audio file using the Chirp 2 model of Google Cloud Speech-to-Text V2 API, providing word-level timestamps for each transcribed word. 
    Args:
        audio_file (str): Path to the local audio file to be transcribed.
            Example: "resources/audio.wav"
    Returns:
        cloud_speech.RecognizeResponse: The response from the Speech-to-Text API containing
        the transcription results.
    """

    # Instantiates a client
    client = SpeechClient(
        client_options=ClientOptions(
            api_endpoint="us-central1-speech.googleapis.com",
        )
    )

    # Reads a file as bytes
    with open(audio_file, "rb") as f:
        audio_content = f.read()

    config = cloud_speech.RecognitionConfig(
        auto_decoding_config=cloud_speech.AutoDetectDecodingConfig(),
        language_codes=["en-US"],
        model="chirp_2",
        features=cloud_speech.RecognitionFeatures(
            enable_word_time_offsets=True, # Enabling word-level timestamps
        )
    )

    request = cloud_speech.RecognizeRequest(
        recognizer=f"projects/{PROJECT_ID}/locations/us-central1/recognizers/_",
        config=config,
        content=audio_content,
    )

    # Transcribes the audio into text
    response = client.recognize(request=request)

    for result in response.results:
        print(f"Transcript: {result.alternatives[0].transcript}")

    return response

Genauigkeit durch Modellanpassung verbessern

import os

from google.cloud.speech_v2 import SpeechClient
from google.cloud.speech_v2.types import cloud_speech
from google.api_core.client_options import ClientOptions

PROJECT_ID = os.getenv("GOOGLE_CLOUD_PROJECT")

def transcribe_sync_chirp2_model_adaptation(
    audio_file: str
) -> cloud_speech.RecognizeResponse:
    """Transcribes an audio file using the Chirp 2 model with adaptation, improving accuracy for specific audio characteristics or vocabulary.
    Args:
        audio_file (str): Path to the local audio file to be transcribed.
            Example: "resources/audio.wav"
    Returns:
        cloud_speech.RecognizeResponse: The response from the Speech-to-Text API containing
        the transcription results.
    """

    # Instantiates a client
    client = SpeechClient(
        client_options=ClientOptions(
            api_endpoint="us-central1-speech.googleapis.com",
        )
    )

    # Reads a file as bytes
    with open(audio_file, "rb") as f:
        audio_content = f.read()

    config = cloud_speech.RecognitionConfig(
        auto_decoding_config=cloud_speech.AutoDetectDecodingConfig(),
        language_codes=["en-US"],
        model="chirp_2",
        # Use model adaptation
        adaptation=cloud_speech.SpeechAdaptation(
          phrase_sets=[
              cloud_speech.SpeechAdaptation.AdaptationPhraseSet(
                  inline_phrase_set=cloud_speech.PhraseSet(phrases=[
                    {
                        "value": "alphabet",
                    },
                    {
                          "value": "cell phone service",
                    }
                  ])
              )
          ]
        )
    )

    request = cloud_speech.RecognizeRequest(
        recognizer=f"projects/{PROJECT_ID}/locations/us-central1/recognizers/_",
        config=config,
        content=audio_content,
    )

    # Transcribes the audio into text
    response = client.recognize(request=request)

    for result in response.results:
        print(f"Transcript: {result.alternatives[0].transcript}")

    return response

Chirp 2 in der Google Cloud -Konsole verwenden

  1. Achten Sie darauf, dass Sie sich für ein Google Cloud-Konto registriert und ein Projekt erstellt haben.
  2. Rufen Sie in der Google Cloud -Console Speech auf.
  3. Aktivieren Sie die API, falls sie noch nicht aktiviert ist.

  4. Sie benötigen einen Arbeitsbereich in der STT-Konsole. Erstellen Sie einen Arbeitsbereich, falls Sie noch keinen haben.

    1. Rufen Sie die Seite „Transkriptionen“ auf und klicken Sie auf Neue Transkription.

    2. Öffnen Sie das Drop-down-Menü Arbeitsbereich und klicken Sie auf Neuer Arbeitsbereich, um einen Arbeitsbereich für die Transkription zu erstellen.

    3. Klicken Sie in der Navigationsleiste Neuen Arbeitsbereich erstellen auf Durchsuchen.

    4. Klicken Sie, um einen neuen Bucket zu erstellen.

    5. Geben Sie einen Namen für den Bucket ein und klicken Sie auf Weiter.

    6. Klicken Sie auf Erstellen, um den Cloud Storage-Bucket zu erstellen.

    7. Klicken Sie nach der Erstellung des Buckets auf Auswählen, um Ihren Bucket auszuwählen.

    8. Klicken Sie auf Erstellen, um den Arbeitsbereich für die Speech-to-Text API V2-Konsole zu erstellen.

  5. Führen Sie eine Transkription Ihres Audios durch.

    Screenshot der Speech-to-Text-Transkriptionsseite, auf der die Dateiauswahl oder der Upload angezeigt werden.

    Wählen Sie auf der Seite Neue Transkription Ihre Audiodatei entweder durch einen Upload (Lokaler Upload) oder durch Angabe einer vorhandenen Cloud Storage-Datei (Cloud Storage) aus.

  6. Klicken Sie auf Weiter, um zu den Transkriptionsoptionen zu gelangen.

    Screenshot der Seite zum Erstellen von Speech-to-Text-Transkriptionen zur Auswahl des Chirp-Modells und zum Senden eines Transkriptionsjobs.

    1. Wählen Sie die Gesprochene Sprache aus, die Sie für die Erkennung mit Chirp von Ihrem zuvor erstellten Erkennungsmodul verwenden möchten.

    2. Wählen Sie im Drop-down-Menü des Modells Chirp – Universal Speech Model aus.

    3. Wählen Sie im Drop-down-Menü Erkennung Ihre neu erstellte Erkennung aus.

    4. Klicken Sie auf Senden, um Ihre erste Erkennungsanfrage mit Chirp auszuführen.

  7. Sehen Sie sich das Transkriptionsergebnis für Chirp 2 an.

    1. Klicken Sie auf der Seite Transkriptionen auf den Namen der Transkription, um das Ergebnis aufzurufen.

    2. Auf der Seite Transkriptionsdetails können Sie Ihr Transkriptionsergebnis anzeigen und optional die Audioinhalte im Browser abspielen.

Bereinigen

Mit den folgenden Schritten vermeiden Sie, dass Ihrem Google Cloud -Konto die in dieser Anleitung verwendeten Ressourcen in Rechnung gestellt werden:

  1. Optional: Revoke the authentication credentials that you created, and delete the local credential file. 

    gcloud auth application-default revoke

  2. Optional: Revoke credentials from the gcloud CLI. 

    gcloud auth revoke

Console

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

    Go to Manage resources

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

    • gcloud

    Delete a Google Cloud project:

    gcloud projects delete PROJECT_ID

    Nächste Schritte