Nutzer mit Cloud Identity-Aware Proxy für Python authentifizieren

Sie können für Anwendungen, die auf von Google Cloud verwalteten Plattformen wie App Engine ausgeführt werden, die Nutzerauthentifizierungs- und Sitzungsverwaltung vermeiden, wenn Sie für die Zugriffssteuerung Identity-Aware Proxy (IAP) verwenden. IAP kann nicht nur den Zugriff auf die Anwendung steuern, sondern auch Informationen über die authentifizierten Nutzer bereitstellen, einschließlich der E-Mail-Adresse und einer persistenten Anwendungskennung in Form neuer HTTP-Header.

Lernziele

  • Für Nutzer der App Engine-Anwendung festlegen, dass sie sich mithilfe von IAP authentifizieren müssen

  • Auf Identitäten von Nutzern in der Anwendung zugreifen, um die E-Mail-Adresse des aktuellen Nutzers aufzurufen

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 der in diesem Dokument beschriebenen Aufgaben können Sie weitere Kosten vermeiden, indem Sie die erstellten Ressourcen löschen. Weitere Informationen finden Sie unter Bereinigen.

Hinweis

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

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

    Zur Projektauswahl

  3. Installieren Sie die Google Cloud CLI.

  4. Führen Sie folgenden Befehl aus, um die gcloud CLI zu initialisieren: 

    gcloud init
    5.

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

    Zur Projektauswahl

  6. Installieren Sie die Google Cloud CLI.

  7. Führen Sie folgenden Befehl aus, um die gcloud CLI zu initialisieren: 

    gcloud init
    8.

Hintergrund

In dieser Anleitung werden Nutzer mithilfe von IAP authentifiziert. Dies ist nur eine von mehreren möglichen Vorgehensweisen zur Authentifizierung. Weitere Informationen über die verschiedenen Methoden zur Authentifizierung von Nutzern finden Sie im Abschnitt Authentifizierungskonzepte.

Anwendung "Hello user-email-address"

Die Anwendung für diese Anleitung ist eine App Engine-Minimalanwendung vom Typ "Hello World", mit einem untypischen Feature: Anstelle von "Hello World" wird "Hello user-email-address" angezeigt, wobei user-email-address die E-Mail-Adresse des authentifizierten Nutzers ist.

Zur Bereitstellung dieser Funktionalität werden die Authentifizierungsinformationen ausgewertet, die der IAP-Dienst jeder Webanfrage hinzufügt, die er an die Anwendung weiterleitet. Jeder Webanfrage an Ihre Anwendung werden drei neue Anfrageheader hinzugefügt. Die ersten beiden Header sind Nur-Text-Strings, mit denen Sie den Nutzer identifizieren können. Der dritte Header ist ein kryptografisch signiertes Objekt mit denselben Informationen.

  • X-Goog-Authenticated-User-Email: Ein Nutzer wird durch seine E-Mail-Adresse identifiziert. Speichern Sie keine personenbezogenen Daten, wenn dies für Ihre Anwendung möglich ist. Diese Anwendung speichert keine Daten, sondern gibt sie lediglich an den Nutzer zurück.

  • X-Goog-Authenticated-User-Id: Diese von Google zugewiesene Nutzer-ID stellt keine Information über den Nutzer dar. Eine Anwendung kann aber aufgrund der Nutzer-ID feststellen, dass ein angemeldeter Nutzer zuvor schon einmal authentifiziert wurde.

  • X-Goog-Iap-Jwt-Assertion: Sie können Google Cloud-Anwendungen so konfigurieren, dass neben Webanfragen aus dem Internet auch Webanfragen von anderen Cloud-Anwendungen unter Umgehung von IAP akzeptiert werden. Wenn eine Anwendung in dieser Weise konfiguriert ist, besteht die Möglichkeit, dass solche Anfragen gefälschte Header haben. Anstatt der oben genannten Nur-Text-Header können Sie deshalb auch den kryptografisch signierten Header verwenden und verifizieren. Damit lässt sich prüfen, ob die Informationen von Google bereitgestellt wurden. Die E-Mail-Adresse des Nutzers sowie eine nichtflüchtige Nutzer-ID stehen als Teil dieses signierten Headers zur Verfügung.

Wenn die Anwendung so konfiguriert ist, dass nur Webanfragen aus dem Internet darauf zugreifen können, und dafür gesorgt ist, dass niemand den IAP-Dienst für die Anwendung deaktivieren kann, muss für den Abruf einer eindeutigen Nutzer-ID nur eine einzige Codezeile geschrieben werden:

user_id = request.headers.get('X-Goog-Authenticated-User-ID')

Eine robuste Anwendung sollte jedoch auf Fehler vorbereitet sein, etwa, wenn unerwartete Konfigurations- oder Umgebungsprobleme auftreten. Daher empfehlen wir stattdessen, eine Funktion zu erstellen, die den kryptografisch signierten Header verwendet und verifiziert. Die Signatur eines solchen Headers kann nicht gefälscht und kann nach erfolgter Verifizierung zur Rückgabe der Identifizierung verwendet werden.

Quellcode erstellen

  1. Erstellen Sie mit einem Texteditor eine Datei mit dem Namen main.py und fügen Sie den folgenden Code ein:

    authentication-users/main.py 
    import sys

from flask import Flask
app = Flask(__name__)

CERTS = None
AUDIENCE = None

def certs():
    """Returns a dictionary of current Google public key certificates for
    validating Google-signed JWTs. Since these change rarely, the result
    is cached on first request for faster subsequent responses.
    """
    import requests

    global CERTS
    if CERTS is None:
        response = requests.get(
            'https://www.gstatic.com/iap/verify/public_key'
        )
        CERTS = response.json()
    return CERTS

def get_metadata(item_name):
    """Returns a string with the project metadata value for the item_name.
    See https://cloud.google.com/compute/docs/storing-retrieving-metadata for
    possible item_name values.
    """
    import requests

    endpoint = 'http://metadata.google.internal'
    path = '/computeMetadata/v1/project/'
    path += item_name
    response = requests.get(
        '{}{}'.format(endpoint, path),
        headers={'Metadata-Flavor': 'Google'}
    )
    metadata = response.text
    return metadata

def audience():
    """Returns the audience value (the JWT 'aud' property) for the current
    running instance. Since this involves a metadata lookup, the result is
    cached when first requested for faster future responses.
    """
    global AUDIENCE
    if AUDIENCE is None:
        project_number = get_metadata('numeric-project-id')
        project_id = get_metadata('project-id')
        AUDIENCE = '/projects/{}/apps/{}'.format(
            project_number, project_id
        )
    return AUDIENCE

def validate_assertion(assertion):
    """Checks that the JWT assertion is valid (properly signed, for the
    correct audience) and if so, returns strings for the requesting user's
    email and a persistent user ID. If not valid, returns None for each field.
    """
    from jose import jwt

    try:
        info = jwt.decode(
            assertion,
            certs(),
            algorithms=['ES256'],
            audience=audience()
            )
        return info['email'], info['sub']
    except Exception as e:
        print('Failed to validate assertion: {}'.format(e), file=sys.stderr)
        return None, None

@app.route('/', methods=['GET'])
def say_hello():
    from flask import request

    assertion = request.headers.get('X-Goog-IAP-JWT-Assertion')
    email, id = validate_assertion(assertion)
    page = "<h1>Hello {}</h1>".format(email)
    return page

    Die Datei main.py wird weiter unten im Abschnitt Erläuterungen zum Code dieser Anleitung ausführlich erläutert.

  2. Erstellen Sie eine weitere Datei mit dem Namen requirements.txt und fügen Sie Folgendes ein:

    authentication-users/requirements.txt 
    Flask==2.1.2
cryptography==37.0.2
python-jose[cryptography]==3.3.0
requests==2.27.1

    In der Datei requirements.txt sind alle nicht standardmäßigen Python-Bibliotheken aufgeführt, die App Engine zum Laden benötigt:

    • Flask ist das für die Anwendung verwendete Python-Web-Framework.

    • cryptography ist ein Modul, das leistungsstarke kryptografische Funktionen bietet.

    • python-jose[cryptography] stellt die Prüf- und Decodierungsfunktion des JWT bereit.

    • requests ruft Daten von Websites ab.

  3. Erstellen Sie eine Datei mit dem Namen app.yaml und fügen Sie den folgenden Text ein:

    authentication-users/app.yaml 
    runtime: python37

    Die Datei app.yaml gibt für App Engine an, welche Sprachumgebung Ihr Code benötigt.

Code verstehen

In diesem Abschnitt wird gezeigt, wie der Code in main.py funktioniert. Wenn Sie nur die Anwendung ausführen möchten, können Sie mit dem Abschnitt Anwendung bereitstellen fortfahren.

Der im Folgenden aufgeführte Code ist in der Datei main.py enthalten. Wenn eine HTTP GET-Anfrage an die Startseite von der Anwendung empfangen wird, ruft das Flask-Framework die Funktion say_hello auf:

authentication-users/main.py 
@app.route('/', methods=['GET'])
def say_hello():
    from flask import request

    assertion = request.headers.get('X-Goog-IAP-JWT-Assertion')
    email, id = validate_assertion(assertion)
    page = "<h1>Hello {}</h1>".format(email)
    return page

Die Funktion say_hello ruft den JWT-Assertion-Headerwert ab, den IAP aus der eingehenden Anfrage hinzugefügt hat, und ruft eine Funktion auf, um diesen kryptografisch signierten Wert zu validieren. Der erste zurückgegebene Wert (E-Mail-Adresse) wird dann für eine Minimalwebseite verwendet, die erstellt und zurückgegeben wird.

authentication-users/main.py 
def validate_assertion(assertion):
    """Checks that the JWT assertion is valid (properly signed, for the
    correct audience) and if so, returns strings for the requesting user's
    email and a persistent user ID. If not valid, returns None for each field.
    """
    from jose import jwt

    try:
        info = jwt.decode(
            assertion,
            certs(),
            algorithms=['ES256'],
            audience=audience()
            )
        return info['email'], info['sub']
    except Exception as e:
        print('Failed to validate assertion: {}'.format(e), file=sys.stderr)
        return None, None

Die Funktion validate_assertion prüft mithilfe der Funktion jwt.decode aus der Drittanbieterbibliothek jose, ob die Assertion korrekt signiert ist, und extrahiert damit die Nutzlastinformationen aus der Assertion. Diese Informationen sind die E-Mail-Adresse des authentifizierten Nutzers sowie eine persistente eindeutige ID für den Nutzer. Wenn die Assertion nicht decodiert werden kann, gibt diese Funktion für jeden dieser Werte None zurück und eine Meldung über die Erfassung des Fehlers aus.

Damit eine JWT-Assertion validiert werden kann, müssen die Public-Key-Zertifikate der Entität, die die Assertion signiert hat (in diesem Fall Google), und das Ziel (Identitätsanbieter) bekannt sein, für das die Assertion bestimmt ist. Bei einer App Engine-Anwendung ist das Ziel ein String mit Identifizierungsinformationen für das Google Cloud-Projekt. Die Funktion ruft diese Zertifikate und den Zielstring aus den Funktionen ab, die zuvor ausgeführt wurden.

authentication-users/main.py 
def audience():
    """Returns the audience value (the JWT 'aud' property) for the current
    running instance. Since this involves a metadata lookup, the result is
    cached when first requested for faster future responses.
    """
    global AUDIENCE
    if AUDIENCE is None:
        project_number = get_metadata('numeric-project-id')
        project_id = get_metadata('project-id')
        AUDIENCE = '/projects/{}/apps/{}'.format(
            project_number, project_id
        )
    return AUDIENCE

Sie können die numerische ID und den Namen des Google Cloud-Projekts selbst ermitteln und in den Quellcode einfügen oder dies von der Funktion audience erledigen lassen. Diese Funktion fragt den Standard-Metadatendienst ab, der allen App Engine-Anwendungen zur Verfügung steht. Da sich der Metadatendienst außerhalb des Anwendungscodes befindet, wird das jeweilige Ergebnis in einer globalen Variablen gespeichert. Diese Variable kann dann in nachfolgenden Aufrufen zurückgegeben werden, ohne dass Metadaten abgerufen werden müssen.

authentication-users/main.py 
def get_metadata(item_name):
    """Returns a string with the project metadata value for the item_name.
    See https://cloud.google.com/compute/docs/storing-retrieving-metadata for
    possible item_name values.
    """
    import requests

    endpoint = 'http://metadata.google.internal'
    path = '/computeMetadata/v1/project/'
    path += item_name
    response = requests.get(
        '{}{}'.format(endpoint, path),
        headers={'Metadata-Flavor': 'Google'}
    )
    metadata = response.text
    return metadata

Der App Engine-Metadatendienst und vergleichbare Metadatendienste für andere Google Cloud-Computing-Dienste verhalten sich wie eine Website und werden mit Standardwebabfragen abgefragt. Er ist jedoch keine externe Website, sondern ein internes Feature, das angeforderte Informationen zur ausgeführten Anwendung zurückgibt. Sie können also ohne Sicherheitsbedenken http-Anfragen anstelle von https-Anfragen verwenden. Mit dem Dienst werden die aktuellen Google Cloud-Kennungen abgerufen, die zur Bestimmung des gewünschten Ziels der JWT-Assertion erforderlich ist.

authentication-users/main.py 
def certs():
    """Returns a dictionary of current Google public key certificates for
    validating Google-signed JWTs. Since these change rarely, the result
    is cached on first request for faster subsequent responses.
    """
    import requests

    global CERTS
    if CERTS is None:
        response = requests.get(
            'https://www.gstatic.com/iap/verify/public_key'
        )
        CERTS = response.json()
    return CERTS

Für die Verifizierung einer digitalen Signatur wird das Public-Key-Zertifikat des Signaturgebers benötigt. Google stellt eine Website zur Verfügung, die alle aktuell verwendeten Public-Key-Zertifikate zurückgibt. Diese Ergebnisse werden im Cache gespeichert, falls sie in der gleichen Anwendungsinstanz noch einmal benötigt werden.

Anwendung bereitstellen

Jetzt können Sie die Anwendung bereitstellen und IAP aktivieren, damit sich Nutzer authentifizieren müssen, bevor sie auf die Anwendung zugreifen können.

  1. Wechseln Sie in Ihrem Terminalfenster zum Verzeichnis mit der Datei app.yaml und stellen Sie die Anwendung in App Engine bereit:

    gcloud app deploy

  2. Wählen Sie bei entsprechender Aufforderung eine Region in der Nähe aus.

  3. Wenn Sie gefragt werden, ob Sie den Bereitstellungsvorgang fortsetzen möchten, geben Sie Y ein.

    Ihre Anwendung ist dann innerhalb weniger Minuten online verfügbar.

  4. Rufen Sie die Anwendung auf:

    gcloud app browse

    Kopieren Sie in der Ausgabe die Webadresse der Anwendung (web-site-url).

  5. Fügen Sie web-site-url in ein Browserfenster ein, um die Anwendung zu öffnen.

    Es wird keine E-Mail-Adresse angezeigt, da Sie IAP noch nicht verwenden und damit keine Nutzerinformationen an die Anwendung gesendet werden.

IAP aktivieren

Nachdem jetzt eine App Engine-Instanz vorhanden ist, können Sie sie mit IAP schützen:

  1. Rufen Sie in der Google Cloud Console die Seite Identity-Aware Proxy auf.

    Zur Seite "Identity-Aware Proxy"

  2. Da Sie zum ersten Mal eine Authentifizierungsoption für dieses Projekt aktiviert haben, werden Sie in einer Meldung darauf hingewiesen, dass Sie den OAuth-Zustimmungsbildschirm konfigurieren müssen, bevor Sie IAP verwenden können.

    Klicken Sie auf Zustimmungsbildschirm konfigurieren.

  3. Geben Sie auf dem Tab OAuth-Zustimmungsbildschirm der Seite Anmeldedaten Werte in die folgenden Felder ein:

    • Wenn sich Ihr Konto in einer Google Workspace-Organisation befindet, wählen Sie Extern aus und klicken Sie auf Erstellen. Die Anwendung ist anfangs nur für Nutzer verfügbar, die Sie ausdrücklich zulassen.

    • Geben Sie im Feld Name der Anwendung den Namen IAP Example ein.

    • Geben Sie im Feld Support-E-Mail-Adresse Ihre E-Mail-Adresse ein.

    • Geben Sie im Feld Autorisierte Domain den Hostnamen-Teil der Anwendungs-URL ein, z. B. iap-example-999999.uc.r.appspot.com. Drücken Sie die Taste Enter, nachdem Sie den Hostnamen im Feld eingegeben haben.

    • Geben Sie im Feld Link zur Startseite der Anwendung die URL für Ihre Anwendung ein, z. B. https://iap-example-999999.uc.r.appspot.com/.

    • Verwenden Sie zu Testzwecken im Feld Link zur Datenschutzerklärung der Anwendung die URL für den Link zur Startseite.

  4. Klicken Sie auf Speichern. Wenn Sie aufgefordert werden, Anmeldedaten zu erstellen, können Sie das Fenster schließen.

  5. Rufen Sie in der Cloud Console die Seite Identity-Aware Proxy auf.

    Zur Seite "Identity-Aware Proxy"

  6. Klicken Sie zum Aktualisieren der Seite auf Aktualisieren . Auf der Seite wird eine Liste von Ressourcen angezeigt, die Sie schützen können.

  7. Klicken Sie in die Spalte IAP, um IAP für die Anwendung zu aktivieren.

  8. Rufen Sie in Ihrem Browser noch einmal web-site-url auf.

  9. Anstelle der Webseite wird ein Anmeldebildschirm zur Authentifizierung angezeigt. Wenn Sie sich anmelden, wird Ihnen der Zugriff verweigert, da in IAP keine Liste von Nutzern vorhanden ist, die für die Anwendung zugelassen sind.

Autorisierte Nutzer in die Anwendung einfügen

  1. Rufen Sie in der Cloud Console die Seite „Identity-Aware Proxy“ auf.

    Zur Seite "Identity-Aware Proxy"

  2. Klicken Sie auf das Kästchen für die App Engine-Anwendung und dann auf Hauptkonto hinzufügen.

  3. Geben Sie allAuthenticatedUsers ein und wählen Sie dann die Cloud IAP-Rolle Nutzer von IAP-gesicherten Web-Apps aus.

  4. Klicken Sie auf Speichern.

Nun hat jeder Nutzer, der von Google authentifiziert werden kann, die Möglichkeit, auf die Anwendung zuzugreifen. Bei Bedarf können Sie den Zugriff weiter einschränken und dafür etwa eine oder mehr Personen bzw. Gruppen als Hauptkonto hinzufügen:

  • Gmail- oder Google Workspace-E-Mail-Adressen

  • E-Mail-Adresse einer Google-Gruppe

  • Google Workspace-Domainname

Auf die Anwendung zugreifen

  1. Rufen Sie im Browser web-site-url auf:

  2. Klicken Sie zum Aktualisieren der Seite auf Aktualisieren .

  3. Melden Sie sich auf dem Anmeldebildschirm mit Ihren Google-Anmeldedaten an.

    Die Seite "Hello user-email-address" wird mit Ihrer E-Mail-Adresse angezeigt.

    Wenn Sie noch immer die gleiche Seite wie zuvor sehen, aktualisiert der Browser neue Anfragen möglicherweise nicht vollständig, nachdem IAP jetzt aktiviert ist. Schließen Sie in diesem Fall alle Browserfenster, öffnen Sie sie wieder und versuchen Sie es noch einmal.

Konzepte der Authentifizierung

Es gibt mehrere Möglichkeiten für Anwendungen, Nutzer zu authentifizieren und den Zugriff auf autorisierte Nutzer einzuschränken. In den folgenden Abschnitten werden gängige Authentifizierungsmethoden dargestellt, wobei die Methoden mit höherem Aufwand für die Anwendung zuerst aufgeführt sind.

Option Vorteile Nachteile
Authentifizierung von Anwendungen
  • App kann auf jeder Plattform mit und ohne Internetverbindung ausgeführt werden
  • Die Nutzer müssen keinen anderen Dienst verwenden, um die Authentifizierung zu verwalten.
  • Die Anmeldedaten der App müssen sicher verwaltet und vor Offenlegung geschützt werden
  • Die App muss Sitzungsdaten für angemeldete Nutzer speichern
  • Die App muss Nutzerregistrierung, Passwortänderungen und Passwortwiederherstellung bereitstellen.
OAuth2
  • Die Anwendung kann auf jeder mit dem Internet verbundenen Plattform ausgeführt werden, einschließlich einer Entwickler-Workstation
  • Für die App sind keine Nutzerregistrierung, Passwortänderungen oder Passwortwiederherstellungsfunktionen erforderlich.
  • Gefahr der Offenlegung von Nutzerdaten wird an einen anderen Dienst delegiert
  • Neue Sicherheitsmaßnahmen für die Anmeldung, die außerhalb der App verarbeitet werden
  • Nutzer müssen sich beim Identitätsdienst registrieren
  • Die App muss Sitzungsdaten für angemeldete Nutzer speichern
IAP
  • Die App benötigt keinen Code, um Nutzer, die Authentifizierung oder den Sitzungsstatus zu verwalten
  • Die App hat keine Nutzeranmeldedaten, die möglicherweise gehackt wurden
  • Die Anwendung kann nur auf Plattformen ausgeführt werden, die vom Dienst unterstützt werden. Das gilt besonders für bestimmte Google Cloud-Dienste, die IAP unterstützen, z. B. App Engine.

Von der Anwendung verwaltete Authentifizierung

Bei dieser Methode wird jeder Aspekt der Nutzerauthentifizierung von der Anwendung selbst verwaltet. Die Anwendung muss dabei ihre eigene Datenbank mit Nutzeranmeldedaten bereitstellen sowie Nutzersitzungen verwalten. Außerdem muss sie Funktionen zum Verwalten von Nutzerkonten und Passwörtern, zum Prüfen von Nutzeranmeldedaten sowie zum Erstellen, Prüfen und Aktualisieren von Nutzersitzungen bei jeder authentifizierten Anmeldung enthalten. Das folgende Diagramm veranschaulicht diese Methode, bei der die Authentifizierung von der Anwendung verwaltet wird.

Von der Anwendung verwalteter Ablauf

Wie im Diagramm dargestellt, erstellt und verwaltet die App nach der Anmeldung des Nutzers Informationen zur Nutzersitzung. Wenn der Nutzer eine Anfrage an die Anwendung sendet, muss die Anfrage Sitzungsinformationen enthalten, für deren Verifizierung die Anwendung zuständig ist.

Der Hauptvorteil besteht bei diesem Ansatz darin, dass er eigenständig ist und von der Anwendung gesteuert werden kann. Die Anwendung muss dabei nicht im Internet verfügbar sein. Der Hauptnachteil ist, dass die Anwendung nun für die Bereitstellung aller Kontoverwaltungsfunktionen und für den Schutz aller vertraulichen Anmeldedaten zuständig ist.

Externe Authentifizierung mit OAuth2

Eine gute Alternative zur Verwaltung und Ausführung aller Vorgänge in der Anwendung ist die Verwendung eines externen Identitätsdienstes wie Google. Dieser ist für alle Kontoinformationen und Funktionen sowie für den Schutz vertraulicher Anmeldedaten zuständig. Wenn sich dann ein Nutzer bei der Anwendung anmeldet, wird die Anfrage an den Identitätsdienst weitergeleitet, der den Nutzer authentifiziert und die Anfrage mit den erforderlichen Authentifizierungsinformationen an die Anwendung zurücksendet. Weitere Informationen finden Sie unter Als Endnutzer authentifizieren.

Das folgende Diagramm zeigt die externe Authentifizierung mit der OAuth2-Methode.

OAuth2-Ablauf

Der Ablauf im Diagramm beginnt, wenn der Nutzer eine Anfrage zum Zugriff auf die Anwendung sendet. Anstatt direkt zu reagieren, leitet die Anwendung den Browser des Nutzers an die Google-Identitätsplattform weiter. Auf dieser Plattform wird dann eine Seite zur Anmeldung bei Google angezeigt. Nach erfolgreicher Anmeldung wird der Browser des Nutzers zurück zur Anwendung geleitet. Diese Anfrage enthält Informationen, mit denen die Anwendung Informationen über den nun authentifizierten Nutzer abrufen kann. Danach antwortet die Anwendung dem Nutzer.

Diese Methode bietet viele Vorteile für die Anwendung. Alle Kontoverwaltungsfunktionen und Risiken werden dabei an den externen Dienst delegiert. Dieser ist dann auch für die Verbesserung der Anmeldungs- und Kontosicherheit zuständig, die dort ohne Änderung der Anwendung vorgenommen werden kann. Allerdings muss die Anwendung bei dieser Methode Zugriff auf das Internet haben, wie im vorherigen Diagramm gezeigt. Darüber hinaus ist die Anwendung nach der Authentifizierung des Nutzers für die Verwaltung der Sitzungen verantwortlich.

Identity-Aware Proxy

Beim dritten der in dieser Anleitung behandelten Ansätze wird mit IAP die gesamte Authentifizierung und Sitzungsverwaltung mit etwaigen Änderungen an der Anwendung durchgeführt. IAP fängt alle Webanfragen an Ihre Anwendung ab, blockiert alle nicht authentifizierten Anfragen und leitet die anderen weiter, wobei Nutzeridentitätsdaten an jede Anfrage angefügt werden.

Die Verarbeitung von Anfragen wird im folgenden Diagramm gezeigt.

IAP-Ablauf

Anfragen von Nutzern werden von IAP abgefangen und nicht authentifizierte Anfragen werden blockiert. Authentifizierte Anfragen werden an die Anwendung weitergeleitet, wenn der authentifizierte Nutzer in der Liste der zugelassenen Nutzer enthalten ist. An die über IAP weitergeleiteten Anfragen werden Header angefügt, die den Nutzer identifizieren, der die Anfrage gestellt hat.

Die Anwendung muss dabei keine Informationen zu Nutzerkonten oder Sitzungen verarbeiten. Jeder Vorgang, der eine eindeutige Kennung für den Nutzer benötigt, kann diese direkt aus jeder eingehenden Webanfrage abrufen. Dieser Ansatz ist jedoch nur für Computing-Dienste möglich, die IAP unterstützen, beispielsweise App Engine und Load-Balancer. Sie können IAP nicht auf einem lokalen Entwicklungscomputer verwenden.

Bereinigen

Damit Ihrem Google Cloud-Konto die in dieser Anleitung verwendeten Ressourcen nicht in Rechnung gestellt werden, löschen Sie entweder das Projekt, das die Ressourcen enthält, oder Sie behalten das Projekt und löschen die einzelnen Ressourcen.

  1. Wechseln Sie in der Google Cloud Console zur Seite Ressourcen verwalten.

    Zur Seite „Ressourcen verwalten“

  2. Wählen Sie in der Projektliste das Projekt aus, das Sie löschen möchten, und klicken Sie dann auf Löschen.
  3. Geben Sie im Dialogfeld die Projekt-ID ein und klicken Sie auf Shut down (Beenden), um das Projekt zu löschen.