API App Identity para servicios agrupados antiguos

ID de región

El REGION_ID es un código abreviado que Google asigna en función de la región que selecciones al crear tu aplicación. El código no corresponde a un país o provincia, aunque algunos IDs de región pueden parecerse a los códigos de país y provincia que se usan habitualmente. En las aplicaciones creadas después de febrero del 2020, REGION_ID.r se incluye en las URLs de App Engine. En las aplicaciones creadas antes de esa fecha, el ID de región es opcional en la URL.

Más información sobre los IDs de región

Aceptar

La API App Identity permite que una aplicación descubra su ID de aplicación (también llamado ID de proyecto). Con el ID, una aplicación de App Engine puede afirmar su identidad a otras aplicaciones de App Engine, APIs de Google y aplicaciones y servicios de terceros. El ID de aplicación también se puede usar para generar una URL o una dirección de correo electrónico, o para tomar una decisión en tiempo de ejecución.

Esta API es compatible con los tiempos de ejecución de primera generación y se puede usar al actualizar a los tiempos de ejecución de segunda generación correspondientes. Si vas a actualizar al entorno de ejecución de Python 3 de App Engine, consulta la guía de migración para obtener información sobre las opciones de migración de los servicios agrupados antiguos.

Obtener el ID de proyecto

El ID del proyecto se puede encontrar con el método app_identity.get_application_id(). El entorno WSGI o CGI expone algunos detalles de implementación, que gestiona la API.

Obtener el nombre de host de la aplicación

De forma predeterminada, las aplicaciones de App Engine se sirven desde URLs con el formato https://PROJECT_ID.REGION_ID.r.appspot.com, donde el ID del proyecto forma parte del nombre de host. Si una aplicación se sirve desde un dominio personalizado, puede que sea necesario recuperar todo el componente del nombre de host. Para ello, puedes usar el método app_identity.get_default_version_hostname().

Afirmar la identidad en otras aplicaciones de App Engine

Si quieres determinar la identidad de la aplicación de App Engine que está haciendo una solicitud a tu aplicación de App Engine, puedes usar el encabezado de solicitud X-Appengine-Inbound-Appid. El servicio URLFetch añade este encabezado a la solicitud y no se puede modificar, por lo que indica de forma segura el ID del proyecto de la aplicación que realiza la solicitud, si está presente.

Requisitos:

• Solo las llamadas realizadas al dominio appspot.com de tu aplicación contendrán el encabezado X-Appengine-Inbound-Appid. Las llamadas a dominios personalizados no contienen la cabecera.
• Tus solicitudes deben configurarse para que no sigan las redirecciones. Asigna el valor False al parámetro urlfetch.fetch() follow_redirects.

En el controlador de tu aplicación, puedes comprobar el ID entrante leyendo el encabezado X-Appengine-Inbound-Appid y comparándolo con una lista de IDs que tienen permiso para enviar solicitudes. Por ejemplo:

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)

Afirmar la identidad en las APIs de Google

Las APIs de Google utilizan el protocolo OAuth 2.0 para la autenticación y la autorización. La API App Identity puede crear tokens de OAuth que se pueden usar para afirmar que la fuente de una solicitud es la propia aplicación. El método get_access_token() devuelve un token de acceso para un permiso o una lista de permisos. Este token se puede definir en los encabezados HTTP de una llamada para identificar la aplicación que llama.

En el siguiente ejemplo se muestra cómo usar la API App Identity para autenticarse en la API Cloud Storage y obtener una lista de todos los segmentos del proyecto.

Nota: Las bibliotecas de cliente de las APIs de Google también pueden gestionar gran parte de este proceso automáticamente.

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)

Ten en cuenta que la identidad de la aplicación se representa mediante el nombre de la cuenta de servicio, que suele ser [e-mail]. Puedes obtener el valor exacto con el método get_service_account_name(). En los servicios que ofrecen listas de control de acceso, puedes conceder acceso a la aplicación otorgando acceso a esta cuenta.

Afirmar la identidad en servicios de terceros

El token generado por get_access_token() solo funciona con los servicios de Google. Sin embargo, puedes usar la tecnología de firma subyacente para afirmar la identidad de tu aplicación a otros servicios. El método sign_blob() firmará los bytes con una clave privada única para tu aplicación, y el método get_public_certificates() devolverá certificados que se pueden usar para validar la firma.

Nota: Los certificados pueden cambiar de vez en cuando y el método puede devolver varios certificados. Solo se devuelven los certificados que son válidos en ese momento. Si almacenas mensajes firmados, necesitarás una gestión de claves adicional para verificar las firmas más adelante.

A continuación, se muestra un ejemplo de cómo firmar un blob y validar su firma:

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)

Obtener el nombre del segmento de Cloud Storage predeterminado

Cada aplicación puede tener un segmento predeterminado de Cloud Storage, que incluye 5 GB de almacenamiento gratuito y una cuota gratuita para las operaciones de E/S.

Para obtener el nombre del bucket predeterminado, puedes usar la API App Identity. Llama a google.appengine.api.app_identity.app_identity.get_default_gcs_bucket_name.