API App Identity per servizi in bundle precedenti

ID regione

REGION_ID è un codice abbreviato assegnato da Google in base all'area geografica selezionata quando crei l'app. Il codice non corrisponde a un paese o a una provincia, anche se alcuni ID area geografica potrebbero sembrare simili ai codici paese e provincia più utilizzati. Per le app create dopo febbraio 2020, REGION_ID.r è incluso negli URL di App Engine. Per le app esistenti create prima di questa data, l'ID regione è facoltativo nell'URL.

Scopri di più sugli ID regione.

Ottimo

L'API App Identity consente a un'applicazione di rilevare il suo ID applicazione (noto anche come ID progetto). Tramite l'ID, un'applicazione App Engine può confermare la propria identità ad altre applicazioni App Engine, API di Google e servizi e applicazioni di terze parti. L'ID applicazione può essere utilizzato anche per generare un URL o un indirizzo email o per prendere una decisione di runtime.

Questa API è supportata per i runtime di prima generazione e può essere utilizzata quando si esegui l'upgrade ai runtime di seconda generazione corrispondenti. Se stai eseguendo l'aggiornamento al runtime App Engine Python 3, consulta la guida alla migrazione per ulteriori informazioni sulle opzioni di migrazione per i servizi in bundle precedenti.

Acquisizione dell'ID progetto

L'ID progetto può essere trovato utilizzando il metodo app_identity.get_application_id(). L'ambiente WSGI o CGI espone alcuni dettagli di implementazione, che sono gestiti dall'API.

Recupero del nome host dell'applicazione

Per impostazione predefinita, le app App Engine vengono pubblicate da URL nel formato https://PROJECT_ID.REGION_ID.r.appspot.com, in cui l'ID progetto fa parte del nome host. Se un'app viene gestita da un dominio personalizzato, potrebbe essere necessario recuperare l'intero componente nome host. A questo scopo, utilizza il metodo app_identity.get_default_version_hostname().

Rivendicazione dell'identità in altre app App Engine

Se vuoi determinare l'identità dell'app App Engine che effettua una richiesta alla tua app App Engine, puoi utilizzare l'intestazione della richiesta X-Appengine-Inbound-Appid. Questa intestazione viene aggiunta alla richiesta dal servizio URLFetch e non è modificabile dall'utente, quindi indica in modo sicuro l'ID progetto dell'applicazione richiedente, se presente.

Requisiti:

• Solo le chiamate effettuate al dominio appspot.com della tua app conterranno l'intestazione X-Appengine-Inbound-Appid. Le chiamate ai domini personalizzati non contengono l'intestazione.
• Le tue richieste devono essere impostate in modo da non seguire i reindirizzamenti. Imposta il parametro urlfetch.fetch() follow_redirects su False.

Nel gestore dell'applicazione, puoi controllare l'ID in entrata leggendo l'intestazione X-Appengine-Inbound-Appid e confrontandolo con un elenco di ID autorizzati a effettuare richieste. Ad esempio:

appengine/standard/app_identity/incoming/main.py

Visualizza su GitHub

import webapp2

class MainPage(webapp2.RequestHandler):
    allowed_app_ids = [
        'other-app-id',
        'other-app-id-2'
    ]

    def get(self):
        incoming_app_id = self.request.headers.get(
            'X-Appengine-Inbound-Appid', None)

        if incoming_app_id not in self.allowed_app_ids:
            self.abort(403)

        self.response.write('This is a protected page.')

app = webapp2.WSGIApplication([
    ('/', MainPage)
], debug=True)

Rivendicazione dell'identità alle API di Google

Le API di Google utilizzano il protocollo OAuth 2.0 per l'autenticazione e l'autorizzazione. L'API App Identity può creare token OAuth che possono essere utilizzati per dichiarare che l'origine di una richiesta è l'applicazione stessa. Il metodo get_access_token() restituisce un token di accesso per un ambito o un elenco di ambiti. Questo token può quindi essere impostato nelle intestazioni HTTP di una chiamata per identificare l'applicazione di chiamata.

L'esempio seguente mostra come utilizzare l'API App Identity per eseguire l'autenticazione nell'API Cloud Storage e recuperare ed elencare tutti i bucket nel progetto.

Nota: anche le librerie client delle API di Google possono gestire automaticamente molte di queste azioni.

appengine/standard/app_identity/asserting/main.py

Visualizza su GitHub

import json
import logging

from google.appengine.api import app_identity
from google.appengine.api import urlfetch
import webapp2

class MainPage(webapp2.RequestHandler):
    def get(self):
        auth_token, _ = app_identity.get_access_token(
            'https://www.googleapis.com/auth/cloud-platform')
        logging.info(
            'Using token {} to represent identity {}'.format(
                auth_token, app_identity.get_service_account_name()))

        response = urlfetch.fetch(
            'https://www.googleapis.com/storage/v1/b?project={}'.format(
                app_identity.get_application_id()),
            method=urlfetch.GET,
            headers={
                'Authorization': 'Bearer {}'.format(auth_token)
            }
        )

        if response.status_code != 200:
            raise Exception(
                'Call failed. Status code {}. Body {}'.format(
                    response.status_code, response.content))

        result = json.loads(response.content)
        self.response.headers['Content-Type'] = 'application/json'
        self.response.write(json.dumps(result, indent=2))

app = webapp2.WSGIApplication([
    ('/', MainPage)
], debug=True)

Tieni presente che l'identità dell'applicazione è rappresentata dal nome dell'account di servizio, che in genere è [e-mail]. Puoi ottenere il valore esatto con il metodo get_service_account_name(). Per i servizi che offrono ACL, puoi concedere l'accesso all'applicazione concedendo questo accesso all'account.

Rivendicazione dell'identità a servizi di terze parti

Il token generato da get_access_token() funziona solo per i servizi Google. Tuttavia, puoi utilizzare la tecnologia di firma sottostante per rivendicare l'identità della tua applicazione ad altri servizi. Il metodo sign_blob() firmerà i byte utilizzando una chiave privata univoca per la tua applicazione, mentre il metodo get_public_certificates() restituirà certificati che possono essere utilizzati per convalidare la firma.

Nota: i certificati possono essere ruotati di tanto in tanto e il metodo può restituire più certificati. Vengono restituiti solo i certificati attualmente validi; se memorizzi i messaggi firmati avrai bisogno di un'ulteriore gestione delle chiavi per verificare le firme in un secondo momento.

Ecco un esempio che mostra come firmare un blob e convalidarne la firma:

appengine/standard/app_identity/signing/main.py

Visualizza su GitHub

import base64

from Crypto.Hash import SHA256
from Crypto.PublicKey import RSA
from Crypto.Signature import PKCS1_v1_5
from Crypto.Util.asn1 import DerSequence
from google.appengine.api import app_identity
import webapp2

def verify_signature(data, signature, x509_certificate):
    """Verifies a signature using the given x.509 public key certificate."""

    # PyCrypto 2.6 doesn't support x.509 certificates directly, so we'll need
    # to extract the public key from it manually.
    # This code is based on https://github.com/google/oauth2client/blob/master
    # /oauth2client/_pycrypto_crypt.py
    pem_lines = x509_certificate.replace(b' ', b'').split()
    cert_der = base64.urlsafe_b64decode(b''.join(pem_lines[1:-1]))
    cert_seq = DerSequence()
    cert_seq.decode(cert_der)
    tbs_seq = DerSequence()
    tbs_seq.decode(cert_seq[0])
    public_key = RSA.importKey(tbs_seq[6])

    signer = PKCS1_v1_5.new(public_key)
    digest = SHA256.new(data)

    return signer.verify(digest, signature)

def verify_signed_by_app(data, signature):
    """Checks the signature and data against all currently valid certificates
    for the application."""
    public_certificates = app_identity.get_public_certificates()

    for cert in public_certificates:
        if verify_signature(data, signature, cert.x509_certificate_pem):
            return True

    return False

class MainPage(webapp2.RequestHandler):
    def get(self):
        message = 'Hello, world!'
        signing_key_name, signature = app_identity.sign_blob(message)
        verified = verify_signed_by_app(message, signature)

        self.response.content_type = 'text/plain'
        self.response.write('Message: {}\n'.format(message))
        self.response.write(
            'Signature: {}\n'.format(base64.b64encode(signature)))
        self.response.write('Verified: {}\n'.format(verified))

app = webapp2.WSGIApplication([
    ('/', MainPage)
], debug=True)

Recupero del nome del bucket Cloud Storage predefinito

Ogni applicazione può avere un bucket Cloud Storage predefinito, che include 5 GB di spazio di archiviazione gratuito e una quota gratuita per le operazioni di I/O.

Per ottenere il nome del bucket predefinito, puoi utilizzare l'API App Identity. Chiama google.appengine.api.app_identity.app_identity.get_default_gcs_bucket_name.