Categorías
Python

Introducción a Bootstrap 3

 

Tabla de Contenidos

  • ¿Por qué utilizar Google Iniciar sesión para sus usuarios?
  • cómo las aplicaciones de uso Google Login
  • OpenID Conectar detalles
  • Creación de un
  • Google Cliente Creación de sus propias DependenciesImports Web ApplicationFlaskFlask-LoginOAuthLibInstalling, configuración y SetupWeb Aplicación EndpointsTesting Su aplicación localmente
  • Frasco
  • Frasco de sesión
  • OAuthLib
  • Instalación de dependencias
  • importaciones, configuración y configuración
  • de aplicaciones web Endpoints
  • pruebas de una aplicación localmente
  • Conclusión
  • Frasco
  • Frasco de sesión
  • OAuthLib
  • Instalación de dependencias
  • importaciones, configuración y de instalación
  • de aplicaciones web Endpoints
  • pruebas de una aplicación localmente

Usted probablemente ha visto la opción de Google Login en varios sitios web. Algunos sitios también tienen más opciones como Facebook Login o GitHub sesión . Todas estas opciones permiten a los usuarios utilizar las cuentas existentes para utilizar un nuevo servicio.

En este artículo, usted va a trabajar a través de la creación de una aplicación web frasco. Su aplicación permitirá a un usuario iniciar la sesión utilizando su identidad Google en lugar de crear una nueva cuenta. Hay un montón de beneficios con este método de gestión de usuarios. Va a ser más seguro y más simple que la gestión de las combinaciones de nombre de usuario y contraseña tradicionales.

Este artículo será más sencillo si ya entender los conceptos básicos de Python. Sería también ayuda a conocer un poco acerca de los marcos web y solicitudes HTTP, pero eso no es estrictamente necesario.

Al final de este artículo, usted será capaz de:

  • Crear una aplicación web que permite a los Frasco los usuarios inician sesión con Google
  • Crear las credenciales del cliente para interactuar con Google
  • Uso Frasco de inicio de sesión para el usuario gestión de sesión en una aplicación Frasco
  • entender mejor OAuth y OpenID 2 Connect (PeDIP)

usted puede hacer clic en el cuadro de abajo para obtener el código de la aplicación que va a hacer en este artículo:

Descargar proyecto Ejemplo: Haga clic aquí para descargar el código de la aplicación Google Frasco con inicio de sesión que va a construir en este artículo.

¿Por qué utilizar Google Acceder a sus usuarios?

Es posible que desee que los usuarios individuales tienen perfiles. O tal vez desea proporcionar características sólo a ciertos usuarios. En cualquier caso, tendrá que saber quién está interactuando con su solicitud. En otras palabras, que necesita para autenticar a los usuarios e identificar de alguna manera única.

La solución tradicional es utilizar un nombre de usuario único y una contraseña secreta. Su aplicación podría almacenar esa información y pedir que cuando sea necesario. Sin embargo, hay algunas desventajas a que la solución:

  • Usted tiene que gestionar de forma segura las contraseñas.
  • Hay que poner en práctica cualquier cuenta relacionada con la funcionalidad: de dos factores authenticationPassword restablecer
  • autenticación de dos factores
  • restablecimiento de contraseña
  • Tienes que proteger contra los intentos de inicio de sesión maliciosos.
  • sus usuarios tienen que otro nombre de usuario y contraseña.
  • autenticación de dos factores
  • restablecimiento de contraseña

Mediante el uso de Google de inicio de sesión para los usuarios, que empuja todo lo que la responsabilidad de ellos. Su aplicación espera a que el usuario vaya a través de la autenticación. Google le dice a la aplicación de ese usuario. En ese punto, que efectivamente puede acceder a su aplicación.

Usted no tiene que almacenar las contraseñas, y Google se encarga de toda la seguridad.

cómo las aplicaciones de uso Google Login

Hay dos especificaciones muy populares e importantes llamados OAuth y OpenID 2 Connect (PeDIP). PeDIP se construye en la parte superior de OAuth 2, añadiendo algunas nuevas ideas y conceptos.

Estas especificaciones definen cómo una aplicación de terceros puede obtener información de otro servicio. Esto implica generalmente la obtención del consentimiento de un usuario. Para desempaquetar esto un poco, Echemos un vistazo a cómo se aplica esto a la aplicación que está a punto de acumulación.

Estás a punto de escribir una aplicación de terceros, y que permite a un usuario usa un botón Google Login para iniciar sesión. Para hacer eso, Google necesita saber acerca de su aplicación. Afortunadamente, usted puede registrar su aplicación como un cliente de Google.

Una vez que un usuario entra a su aplicación y presiona el botón Iniciar sesión Google , puede enviarlos a Google. A partir de ahí, Google necesita para asegurarse de que el usuario consiente que pasan a lo largo de su correo electrónico y otra información para su aplicación. Si el consentimiento del usuario, Google envía de vuelta un poco de información para su aplicación. A continuación, almacenar esa información y hacer referencia a él más tarde, el registro de manera efectiva en el usuario. Solicitar información

OpenID Conectar detalles

A en nombre de un usuario, debe convertirse en un cliente para el servidor de autenticación, también conocido como el proveedor. Lo primero que se dará cuenta si usted cava en estas especificaciones es que hay una gran cantidad de términos y conceptos que se superponen.

Así como una aplicación de terceros (también conocido como cliente), que desea obtener información del proveedor en nombre del usuario. Hay una serie de pasos que permiten que eso ocurra, y esos pasos deben ocurrir en un orden específico. Es por eso que a veces se oirá OAuth y OpenID 2 Conectar a que se refiere como un apretón de manos , flujo o bailar .

Esas medidas son, en términos generales:

  • Recibe las credenciales del cliente únicas del proveedor.
  • Vamos a usar estas credenciales del cliente para autenticar (demostrar quién eres) al proveedor más adelante.
  • Por lo general, esto incluye el acceso limitado, y está claro para el usuario de lo que el cliente está pidiendo.
  • Esto es como cuando se tiene que aprobar una aplicación en el teléfono para tener acceso a la ubicación o los contactos.

nota: los pasos descritos anteriormente son para el flujo Código de Autorización, según lo definido por OAuth 2.

Esos pasos incluyen ambas las normas mencionadas hasta ahora. OpenID Connect (PeDIP) se construye en la parte superior de OAuth 2, la adición de algunas características y requisitos adicionales, especialmente relacionados con el proceso de autenticación. Aparte de la autenticación se menciona en el flujo anterior, los conceptos OIDC importantes para su aplicación son la configuración del proveedor y userinfo punto final . configuración del proveedor

El contiene información sobre el proveedor, incluyendo la URL exacta que necesita para utilizar para el flujo de OAuth 2. Hay una URL estándar en un proveedor de PeDIP puede utilizar para volver un documento con campos estandarizados.

El userinfo punto final devolverá información sobre el usuario después de que haya pasado por el flujo de OAuth 2. Esto incluirá su correo electrónico y algunos datos básicos perfil que va a utilizar en la aplicación. Con el fin de obtener esta información de los usuarios, se necesita un token de la empresa, tal como se describe en el último paso en el flujo arriba.

Verás los detalles acerca de cómo la configuración del proveedor y la información de usuario de punto final pueden ser utilizados más adelante.

Creación de un cliente de Google

El primer paso para permitir una opción Google Login es registrar su aplicación como un cliente de Google. Vamos a caminar a través de los pasos para hacer eso.

En primer lugar, tenga en cuenta que se necesita una cuenta de Google. Ya tiene uno si utilizas Gmail.

A continuación, vaya a la página de desarrolladores de Google credenciales.

Una vez dentro, se le pedirá que estar de acuerdo con sus términos de servicio. En caso de estar de acuerdo con aquellos, pulsa el botón de Crear credenciales en la página siguiente. Seleccione la opción para el cliente de OAuth ID :

Seleccionar la opción de aplicación web en la parte superior. Puede proporcionar un nombre para el cliente en el campo Nombre también. El nombre que proporcione se mostrará a los usuarios cuando están consintiendo a su aplicación actúe en su nombre.

se le ejecuta la aplicación web a nivel local, por ahora, lo que puede establecer los orígenes de JavaScript autorizados a https://127.0.0.1:5000 y URI de redirección autorizados a https://127.0.0.1:5000/login/callback . Esto permitirá que su aplicación local Frasco para comunicarse con Google.

Por último, golpeó Crear y tomar nota de la ID de cliente y el secreto de cliente. Usted necesitará tanto más tarde.

Creación de su propio Aplicaciones Web

Ahora viene la parte divertida donde se aplica el conocimiento que ha aprendido a crear una aplicación web real! de

deje que se inicie con el objetivo en mente. ¿Quieres crear una aplicación que permite a los usuarios iniciar sesión con su cuenta de Google. Esta solicitud debe ser capaz de recuperar cierta información básica sobre el usuario de Google, como su dirección de correo electrónico. A continuación, la aplicación debe almacenar información básica del usuario de una base de datos.

En primer lugar, sin embargo, vamos a echar un vistazo a la estructura y las bibliotecas que va a utilizar.

Frasco

frasco es una web-marco ligero, un microframework autoproclamado . Viene con una función de herramientas para las tareas básicas que una aplicación web llevará a cabo, como el enrutamiento URL y gastos de peticiones HTTP.

He optado por utilizar el frasco como un ejemplo tanto por su popularidad y simplicidad. Sin embargo, las cosas que has aprendido acerca de OAuth 2 y PeDIP no son específicos para el frasco. De hecho, incluso la biblioteca que va a utilizar para hacer OAuth 2 y PeDIP más fácil es utilizable en cualquier código Python. En otras palabras, con algunas modificaciones menores, puede tomar lo que se aprende aquí y lo aplica a otro marco de su elección.

Frasco de sesión

Otra herramienta que puede utilizar para hacer el manejo más fácil de los usuarios se flask_login, que proporciona gestión de sesiones de usuario .

Esta biblioteca hace un par de cosas detrás de las escenas y le da algunas herramientas para ayudar a los usuarios. Es decir, se proporciona utilidades para que sepan cuando un usuario está conectado y desconectado. Esto se logra mediante la gestión de una sesión de usuario dentro de una cookie del navegador.

También maneja el registro y cierre de sesión de los usuarios, incluyendo la creación de entradas de la base de esos usuarios. Desde el aspecto de su código, aunque, en realidad sólo lo hace todo mucho más simple (que verá en breve).

OAuthLib

Hay una frase común que mantiene muy cierto código compatible con el estándar relacionado con la seguridad y: “No reinventar la rueda”.

OAuth y OpenID Connect 2 normas son complicadas. Echar un vistazo a la RFC y especificaciones, y verá. Son densa. Un error que significa que podría ser la apertura de una vulnerabilidad en su aplicación.

lo tanto, no se van a escribir código para implementar estas normas. Usted va a utilizar un paquete de Python que fue elegido en algunos criterios muy específicos:

hay paquetes de Web-marco-específicos que utilizan esta biblioteca para integrar más estrechamente en el frasco, Django, Pirámide, y otros. Sin embargo, para mantener el código que aprenda aquí marco agnóstica, va a utilizar esta biblioteca directamente sin ningún tipo de envoltorios de lujo.

Instalación de dependencias

Hay una serie de dependencias de terceros que se va a utilizar para hacer su vida más fácil. He aquí un resumen de esas dependencias:

  • Un framework de desarrollo web para hacer tareas de la aplicación web típica más fácil (Frasco)
  • una forma libre de dolor de cabeza de la gestión de las sesiones de usuario (Frasco-Login) biblioteca PeDIP aguerrido
  • A (oauthlib)

Además, utilizará la siguiente: base de datos

  • a para almacenar información acerca de los usuarios que inician sesión en (SQLite)
  • Una manera fácil de usar para enviar peticiones HTTP a Google (solicitudes)
  • Una forma rápida para permitir ejecutar de forma segura con HTTPS localmente (pyOpenSSL)

SQLite es parte de la biblioteca estándar de Python, pero los otros paquetes no lo son. Por lo que tiene un par de dependencias para instalar. Por ahora, vamos a ir a través de la creación de esta aplicación paso a paso.

En primer lugar, tendrá que instalar esas dependencias de terceros mencionados anteriormente. Esto lo hará mediante la creación de un archivo requirements.txt con el siguiente contenido:

requests==2.21.0
Flask==1.0.2
oauthlib==3.0.1
pyOpenSSL==19.0.0
Flask-Login==0.4.1

Nota: Otras versiones de los paquetes puede funcionar, pero estos son versiones que se utilizaron durante la escritura y la prueba de este artículo.

A continuación, se puede instalar esas dependencias utilizando PIP, del paquete de instalación de Python.

Nota: Por lo general se recomienda el uso de entornos virtuales, si vas a ser la instalación de dependencias para diferentes aplicaciones Python en su ordenador. Ver Python entornos virtuales: Una cartilla para aprender más.

Para instalar desde el archivo requirements.txt, ejecute el siguiente comando en el terminal:

$ pip install -r requirements.txt

Ahora ya está listo para el rock and roll! derecho excavación Vamos en el código.

importaciones, configuración y configuración

de inicio mediante la adición de unos pocos archivos para apoyar algunas funciones de base de datos y la gestión básica de usuario. Estos no serán descritos sección por sección, sobre todo porque el buceo en Python detalles de implementación de base de datos es una madriguera de conejo que nos distraiga de nuestra meta.

db.py Mostrar / Ocultar

Este fichero se encargará de algunas funciones de base de datos. Esto es casi línea por línea del oficial tutorial base de datos de Frasco:

# http://flask.pocoo.org/docs/1.0utorial/database/
import sqlite3

import click
from flask import current_app, g
from flask.cli import with_appcontext

def get_db():
if "db" not in g:
g.db = sqlite3.connect(
"sqlite_db", detect_types=sqlite3.PARSE_DECLTYPES
)
g.db.row_factory = sqlite3.Row

return g.db

def close_db(e=None):
db = g.pop("db", None)

if db is not None:
db.close()

def init_db():
db = get_db()

with current_app.open_resource("schema.sql") as f:
db.executescript(f.read().decode("utf8"))

@click.command("init-db")
@with_appcontext
def init_db_command():
"""Clear the existing data and create new tables."""
init_db()
click.echo("Initialized the database.")

def init_app(app):
app.teardown_appcontext(close_db)
app.cli.add_command(init_db_command)

Ahora que tiene algunas utilidades de bases de datos, puede empezar a pensar en el esquema. Usted puede notar que este código está buscando un archivo schema.sql, que se creará a continuación.

El schema.sql archivo es sólo un poco de SQL que creará una tabla de usuario en nuestra base de datos. Se puede ver los campos que va a almacenar por usuario en este archivo.

schema.sql Mostrar / Ocultar

Aquí tienes una sola tabla, usuario, que albergará algunas cosas relacionadas con los usuarios (su nombre, el correo electrónico que se conecten con, y su foto de perfil de Google):

CREATE TABLE user (
id TEXT PRIMARY KEY,
name TEXT NOT NULL,
email TEXT UNIQUE NOT NULL,
profile_pic TEXT NOT NULL
);

el código en el archivo db.py realidad ejecutará este SQL para crear la tabla en su base de datos.

Este archivo siguiente contiene la clase de usuario, que va a almacenar y recuperar información de la base de datos. El cuadro nombre, correo electrónico, y el perfil de todo se recupera de Google, que se verá más adelante en el artículo.

user.py Mostrar / Ocultar

la clase de usuario tiene métodos para obtener un usuario existente en la base de datos y crear un nuevo usuario:

from flask_login import UserMixin

from db import get_db

class User(UserMixin):
def __init__(self, id_, name, email, profile_pic):
self.id = id_
self.name = name
self.email = email
self.profile_pic = profile_pic

@staticmethod
def get(user_id):
db = get_db()
user = db.execute(
"SELECT * FROM user WHERE id = ?", (user_id,)
).fetchone()
if not user:
return None

user = User(
id_=user[0], name=user[1], email=user[2], profile_pic=user[3]
)
return user

@staticmethod
def create(id_, name, email, profile_pic):
db = get_db()
db.execute(
"INSERT INTO user (id, name, email, profile_pic) "
"VALUES (?, ?, ?, ?)",
(id_, name, email, profile_pic),
)
db.commit()

Las declaraciones ejecuta el código SQL en la base de datos, que se recupera de la get_db () Función desde el archivo db.py anterior. Cada nuevo usuario da como resultado la inserción de una fila adicional en la base de datos.

Después de haber creado el db.py, schema.sql y archivos user.py en el código anterior, se puede crear un nuevo archivo app.py. Añadir a que las importaciones siguientes:

# Python standard libraries
import json
import os
import sqlite3

# Third-party libraries
from flask import Flask, redirect, request, url_for
from flask_login import (
LoginManager,
current_user,
login_required,
login_user,
logout_user,
)
from oauthlib.oauth2 import WebApplicationClient
import requests

# Internal imports
from db import init_db_command
from user import User

Vamos a usar todo esto más adelante, así que no es tan importante comprender cada uno de ellos en este momento. La siguiente parte de su app.py es cierta configuración:

# Configuration
GOOGLE_CLIENT_ID = os.environ.get("GOOGLE_CLIENT_ID", None)
GOOGLE_CLIENT_SECRET = os.environ.get("GOOGLE_CLIENT_SECRET", None)
GOOGLE_DISCOVERY_URL = (
"https://accounts.google.com/.well-known/openid-configuration"
)

Aquí es cómo va a almacenar el ID de cliente y Google secreta de cliente, que debe de haber creado anteriormente en este artículo. Estos serán utilizados posteriormente en el flujo PeDIP.

La aplicación intentará obtener las credenciales del cliente mediante la lectura de las variables ambientales. Hay un par de razones para esto:

Muchas personas cometen accidentalmente secretos a los repositorios públicos, lo que representa un riesgo para la seguridad muy en serio. Es mejor para proteger contra el que mediante el uso de variables ambientales.

Consejo: Puede configurar sus credenciales del cliente como variables ambientales en Linux fiesta de terminal y terminal de Mac OS X utilizando la exportación GOOGLE_CLIENT_ID = your_client_id (de manera similar para GOOGLE_CLIENT_SECRET).

Si estás en Windows, puede utilizar el conjunto GOOGLE_CLIENT_ID = your_client_id en Símbolo del sistema.

Como alternativa, podría pegar las cuerdas directamente aquí y almacenarlos en estas variables. Sin embargo , el secreto cliente debe no ser compartida o comprometido con cualquier repositorio público. En otras palabras, tener cuidado de no para comprobar en este archivo si se pegan las credenciales de cliente real aquí.

Por último, por debajo de un cierto código con variables globales y alguna lógica de inicialización de la base de datos ingenuo. La mayor parte de esto, aparte de la inicialización de la base de datos, es la forma estándar para configurar el frasco, matraz de inicio de sesión y OAuthLib, que se lee antes:

# Flask app setup
app = Flask(__name__)
app.secret_key = os.environ.get("SECRET_KEY") or os.urandom(24)

# User session management setup
# https://flask-login.readthedocs.io/en/latest
login_manager = LoginManager()
login_manager.init_app(app)

# Naive database setup
try:
init_db_command()
except sqlite3.OperationalError:
# Assume it's already been created
pass

# OAuth 2 client setup
client = WebApplicationClient(GOOGLE_CLIENT_ID)

# Flask-Login helper to retrieve a user from our db
@login_manager.user_loader
def load_user(user_id):
return User.get(user_id)

Tenga en cuenta que ya está utilizando el ID de cliente de Google para inicializar nuestra oauthlib cliente en el WebApplicationClient.

Puede crear otra variable de entorno que SECRET_KEY Frasco y matraz de inicio de sesión utilizará para firmar criptográficamente galletas y otros artículos.

de aplicaciones web Endpoints

Ahora, para la parte divertida. Vas a escribir cuatro criterios de valoración para la aplicación Web:

Estos criterios de valoración serán definidos por diferentes direcciones URL de su aplicación con nombres muy creativos:

Por supuesto, es posible que desee añadir páginas y funcionalidades adicionales más adelante. El resultado final de esta solicitud será totalmente extensible para añadir todo lo que quiere él.

Vamos a añadir todo el siguiente código para estos parámetros en el archivo app.py. Vamos a echar un vistazo a cada uno de estos criterios de valoración código, uno a la vez.

Página

Esto es muy sofisticado visualmente, pero que va a añadir un poco de lógica ordenada a la pantalla algo diferente si un usuario está conectado. Cuando no está conectado, aparecerá un enlace que dice Google Login .

Al pulsar el enlace redirige a su punto final / inicio de sesión, que iniciará el flujo de entrada. Después de un inicio de sesión con éxito, la página mostrará ahora tanto el correo electrónico de Google del usuario y su foto de perfil público Google!

Sin más, se puede empezar a añadir más código a su archivo app.py:

@app.route("/")
def index():
if current_user.is_authenticated:
return (
"

Hello, {}! You're logged in! Email: {}

"
"

Google Profile Picture:

"
'Google profile pic

'
'Logout'.format(
current_user.name, current_user.email, current_user.profile_pic
)
)
else:
return 'Google Login'

Se habrá dado cuenta de que usted está volviendo HTML como una cadena, que el frasco será capaz de servir. El current_user.is_authenticated es una hermosa adición de la biblioteca matraz de inicio de sesión. Es una manera sencilla para determinar si el usuario actual interactuar con su aplicación se registra o no. Esto le permite aplicar lógica condicional. En este caso, se ha de mostrar la información que haya guardado sobre el usuario si están conectados.

Puede obtener campos de su entrada de base de datos para el usuario con sólo acceder a ellos como atributos del objeto current_user, como current_user.email . Esta es otra adición de Frasco de inicio de sesión.

sesión

Ahora vamos a llegar al flujo de OAuth 2. El botón Google Login desde arriba volverá a dirigir a este punto final. El primer paso para el flujo es de averiguar dónde OAuth 2 Autorización punto final de Google es.

Aquí es donde la línea que separa lo que está definido por OAuth 2 y por OpenID Connect (PeDIP) comienzan a desdibujarse. Como se discutió previamente, OIDC tiene un punto final estándar para una configuración del proveedor , que contiene un montón de OAuth 2 y la información OIDC. El documento con esa información se sirve de un criterio de valoración estándar en todas partes, .bien conocida / openid-configuración.

Suponiendo que ha copiado el código anterior que define GOOGLE_DISCOVERY_URL, aquí está una manera rápida, ingenua, la función para recuperar la configuración del proveedor de Google:

def get_google_provider_cfg():
return requests.get(GOOGLE_DISCOVERY_URL).json()

Consejo: Para hacerlo más robusto, debe agregar control de errores a la llamada a la API de Google, en el caso de la API de Google devuelve un error y no el documento de configuración de proveedor válido.

El campo del documento de configuración de proveedor que necesita se llama authorization_endpoint. Este contendrá la URL tiene que utilizar para iniciar el flujo de OAuth 2 con Google desde la aplicación cliente.

Puede poner toda esa lógica junto con el código siguiente:

@app.route("/login")
def login():
# Find out what URL to hit for Google login
google_provider_cfg = get_google_provider_cfg()
authorization_endpoint = google_provider_cfg["authorization_endpoint"]

# Use library to construct the request for Google login and provide
# scopes that let you retrieve user's profile from Google
request_uri = client.prepare_request_uri(
authorization_endpoint,
redirect_uri=request.base_url + "/callback",
scope=["openid", "email", "profile"],
)
return redirect(request_uri)

Por suerte, oauthlib hace que la solicitud real a Google más fácil. Que utilizó su cliente preconfigurado que ya dio su ID de cliente a Google. A continuación, se proporciona la redirección desea que Google utilice. Por último, se pidió a Google para una serie de OAuth 2 ámbitos.

Se puede pensar en cada ámbito como una pieza separada de la información del usuario. En su caso, usted está pidiendo para el correo electrónico y el perfil básico de la información del usuario de Google. El usuario será, por supuesto, tiene que dar su consentimiento para darle esta información.

Nota:. OpenID es un ámbito necesario para decirle a Google para iniciar el flujo PeDIP, que autenticar al usuario haciendo que inicien sesión en OAuth 2 en realidad no sucede estandarizar la forma de autenticación, así que esto es necesario para nuestro flujo de este caso. de

sesión de devolución de llamada

dejar hacer éste en pedazos, ya que es un poco más complicado que los anteriores unos criterios de valoración.

Una vez que redirigir al punto final de autorización de Google, suceden muchas cosas en el extremo de Google.

El punto final de conexión en la aplicación es el punto de partida para todo el trabajo de Google autenticación del usuario y pedir consentimiento. Una vez que el usuario inicia sesión con Google y acepta compartir su correo electrónico y la información básica de perfil con su aplicación, Google genera un código único que se envía de nuevo a su aplicación.

Como recordatorio, aquí están los pasos PeDIP se lee antes:

Cuando Google envía ese código único, que va a estar enviando a este inicio de sesión de devolución de llamada de punto final en su aplicación. Así que el primer paso es definir el punto final y conseguir que el código:

@app.route("/login/callback")
def callback():
# Get authorization code Google sent back to you
code = request.args.get("code")

Lo siguiente que se va a hacer es enviar que volver código de punto final de contadores a Google. Después de Google verifica sus credenciales del cliente, se le enviará de vuelta fichas que permitirán que se autentique a otros criterios de valoración de Google en nombre del usuario, incluyendo la userinfo punto final se lee antes. En su caso, sólo se pedirá para ver información básica de perfil, así que eso es lo único que puede hacer con las fichas.

Para empezar, es necesario averiguar qué punto final de contadores a Google es. Vamos a usar el documento de configuración del proveedor de nuevo:

# Find out what URL to hit to get tokens that allow you to ask for
# things on behalf of a user
google_provider_cfg = get_google_provider_cfg()
token_endpoint = google_provider_cfg["token_endpoint"]

oauthlib viene a su rescate un par de veces en este siguiente bloque de código. En primer lugar, es necesario construir la petición de señal. Una vez que la solicitud se construye, va a utilizar la biblioteca de solicitudes para enviar realmente a cabo. Entonces oauthlib, una vez más, le ayudará con las fichas de análisis de la respuesta:

# Prepare and send a request to get tokens! Yay tokens!
token_url, headers, body = client.prepare_token_request(
token_endpoint,
authorization_response=request.url,
redirect_url=request.base_url,
code=code
)
token_response = requests.post(
token_url,
headers=headers,
data=body,
auth=(GOOGLE_CLIENT_ID, GOOGLE_CLIENT_SECRET),
)

# Parse the tokens!
client.parse_request_body_response(json.dumps(token_response.json()))

Ahora que tiene las herramientas necesarias para obtener la información del perfil del usuario, es necesario pedir a Google para ello. Por suerte, PeDIP define una información de punto final del usuario, y su dirección URL de un determinado proveedor está estandarizado en la configuración del proveedor. Se puede obtener la ubicación comprobando el campo userinfo_endpoint en el documento de configuración del proveedor. A continuación, puede utilizar oauthlib añadir el testigo a su solicitud y uso de solicitudes para enviar hacia fuera:

# Now that you have tokens (yay) let's find and hit the URL
# from Google that gives you the user's profile information,
# including their Google profile image and email
userinfo_endpoint = google_provider_cfg["userinfo_endpoint"]
uri, headers, body = client.add_token(userinfo_endpoint)
userinfo_response = requests.get(uri, headers=headers, data=body)

El siguiente paso en su viaje es analizar la respuesta del userinfo punto final. Google utiliza un campo opcional, email_verified, para confirmar que no sólo ha creado el usuario de una cuenta, pero han verificado la dirección de correo electrónico para completar la creación de la cuenta. Es generalmente seguro para comprobar de forma condicional para esta verificación, ya que es otro nivel de seguridad que ofrece Google.

Una vez dicho esto, voy a revisar para eso, y si Google dice que el usuario se verifica, entonces te PARSE su información. Las 4 piezas de información básica perfil que vamos a usar son:

todo ese análisis sintáctico resultados en el siguiente código:

# You want to make sure their email is verified.
# The user authenticated with Google, authorized your
# app, and now you've verified their email through Google!
if userinfo_response.json().get("email_verified"):
unique_id = userinfo_response.json()["sub"]
users_email = userinfo_response.json()["email"]
picture = userinfo_response.json()["picture"]
users_name = userinfo_response.json()["given_name"]
else:
return "User email not available or not verified by Google.", 400

Los pasos finales en esta devolución de llamada son: El código

para cumplir esos pasos es la siguiente:

# Create a user in your db with the information provided
# by Google
user = User(
id_=unique_id, name=users_name, email=users_email, profile_pic=picture
)

# Doesn't exist? Add it to the database.
if not User.get(unique_id):
User.create(unique_id, users_name, users_email, picture)

# Begin user session by logging the user in
login_user(user)

# Send user back to homepage
return redirect(url_for("index"))

Entonces, ¿qué está haciendo aquí es la creación de una nueva fila en la base de datos para el usuario, si es que aún no existen. Entonces, vas a empezar una sesión usando Frasco de inicio de sesión.

Salir

El punto final de cierre de sesión es mucho menos código que los últimos puntos finales. Que acaba de llamar una función de cierre de sesión y redirigir a la página inicial. Hecho y hecho. Aquí está:

@app.route("/logout")
@login_required
def logout():
logout_user()
return redirect(url_for("index"))

El decorador @login_required es algo importante mencionar aquí. Es otra herramienta de la caja de herramientas matraz de inicio de sesión y se asegurará de que sólo los usuarios registrados pueden acceder a este punto final. Puede usar esta opción si solamente los usuarios registrados debe ser el acceso a algo. En este caso, sólo los usuarios registrados pueden cerrar la sesión.

Prueba

Su aplicación localmente

Puede ejecutar la aplicación frasco en su computadora local para probar el flujo de entrada mediante la adición de un poco de código final a app.py:

if __name__ == "__main__":
app.run(ssl_context="adhoc")

Usted puede ejecutar su aplicación Frasco con el siguiente comando en el terminal:

$ python app.py

Nota: Debido a la lógica de inicialización de la base de datos ingenua, la primera vez que se ejecuta este comando, se creará la base de datos. Para iniciar la aplicación, tiene que ejecutar el mismo comando nuevo .

frasco debe imprimir en su terminal en el que se está ejecutando el servidor de desarrollo. Debe ser https://127.0.0.1:5000/.

Tenga en cuenta que el servidor de desarrollo del frasco se ejecuta localmente y usando HTTPS para garantizar una conexión cifrada con Google. Esto se consigue por el ssl_context = argumento «ad hoc» para app.run en el código anterior. Esto requiere que tenga instalado el paquete pyOpenSSL.

La desventaja es que el certificado utilizado se genera sobre la marcha, por lo que cuando se va a https://127.0.0.1:5000/ en su navegador, es probable que le dará una gran pantalla de advertencia acerca de su conexión floja o no estar privado. Puede pasar por alto de manera efectiva estas advertencias.

Una vez pasada la pantalla de advertencia, debería ver un botón que dice Google Login . Al pulsarlo le enviará a la entrada oficial de Google. Después de iniciar sesión, Google le pedirá que autoriza la utilización de la “aplicación de terceros” para acceder a su correo electrónico y el perfil de la información.

Después de dar su consentimiento, se le redirige a su aplicación Frasco, donde la página debe mostrar su correo electrónico de Google y la imagen de perfil público! Por último, un botón Cerrar sesión le permite, así, cerrar la sesión.

Conclusión

Permitir a los usuarios utilizar sus cuentas existentes para acceder a la aplicación web tiene muchos beneficios. Lo más importante, la seguridad y la complejidad de la gestión de cuentas no tiene que descansar sobre sus hombros. Esto le libera para escribir su fantasía nueva aplicación web sin preocuparse por los detalles Nitty Gritty de autenticación de dos factores y similares.

La aplicación que ha hecho en este artículo es un buen punto de partida. Puede hacer clic en la casilla de abajo para obtener el código:

Descargar proyecto Ejemplo: Haga clic aquí para descargar el código de la aplicación Google Frasco con inicio de sesión que va a construir en este artículo.

Su próximo paso podría ser que hacer lo siguiente:

  • retrabajo la inicialización de la base de datos a suceder por separado de ejecución de la aplicación
  • separar el HTML / CSS a partir del código Python para facilitar la gestión: Se podría utilizar también podría templates.You cargar archivos estáticos (como JS y CSS) de otra parte.
  • Se puede usar plantillas.
  • También puede cargar archivos estáticos (como JS y CSS) de otra parte.
  • Anfitrión su aplicación en la nube
  • comprar un nombre de dominio
  • Utilizar un certificado SSL real y deshacerse de ese molesto aviso
  • Usted podría utilizar plantillas.
  • También puede cargar archivos estáticos (como JS y CSS) de otra parte.

En este artículo, usted ha pasado por los fundamentos de OAuth y OpenID 2 Conectar. Usted ha visto cómo utilizar los paquetes de Python conocidas para crear una aplicación web que permite a los usuarios iniciar sesión con su cuenta de Google existente. Lo más importante, usted tiene código de ejemplo que sirve como un buen punto de partida para su próxima aplicación web!

Deja un comentario

Tu dirección de correo electrónico no será publicada. Los campos obligatorios están marcados con *