Descarga google auth library ruby - Descarga del código fuente google auth library ruby

Biblioteca de autenticación de Google para Ruby

Página principal: http://www.github.com/googleapis/google-auth-library-ruby
Autores: Tim Emiola
Derechos de autor: Copyright © 2015 Google, Inc.
Licencia: apache 2.0

Descripción

Esta es la biblioteca cliente Ruby compatible oficialmente de Google para utilizar la autorización y autenticación OAuth 2.0 con las API de Google.

Instalar

Asegúrese de que https://rubygems.org/ esté en sus fuentes de gemas.

Para el uso normal del cliente, esto es suficiente:

$ gem install googleauth

Uso de ejemplo

 require 'googleauth'

# Get the environment configured authorization
scopes =  [ 'https://www.googleapis.com/auth/cloud-platform' ,
           'https://www.googleapis.com/auth/compute' ]
authorization = Google :: Auth . get_application_default ( scopes )

# Add the the access token obtained using the authorization to a hash, e.g
# headers.
some_headers = { }
authorization . apply ( some_headers )

Credenciales predeterminadas de la aplicación

Esta biblioteca proporciona una implementación de las credenciales predeterminadas de la aplicación para Ruby.

Las credenciales predeterminadas de la aplicación proporcionan una forma sencilla de obtener credenciales de autorización para usarlas al llamar a las API de Google.

Son más adecuados para los casos en los que la llamada debe tener la misma identidad y nivel de autorización para la aplicación independientemente del usuario. Este es el enfoque recomendado para autorizar llamadas a las API de la nube, especialmente cuando estás creando una aplicación que utiliza Google Compute Engine.

Credenciales de usuario

La biblioteca también brinda soporte para solicitar y almacenar credenciales de usuario (OAuth2 de 3 patas). Actualmente hay dos implementaciones disponibles: un autorizador genérico útil para aplicaciones de línea de comandos o integraciones personalizadas, así como una variante web adaptada a aplicaciones basadas en Rack.

Los autorizadores están destinados a casos de uso de autorización. Para iniciar sesión, consulte Google Identity Platform

Ejemplo (web)

 require 'googleauth'
require 'googleauth/web_user_authorizer'
require 'googleauth/stores/redis_token_store'
require 'redis'

client_id = Google :: Auth :: ClientId . from_file ( '/path/to/client_secrets.json' )
scope = [ 'https://www.googleapis.com/auth/drive' ]
token_store = Google :: Auth :: Stores :: RedisTokenStore . new ( redis : Redis . new )
authorizer = Google :: Auth :: WebUserAuthorizer . new (
  client_id , scope , token_store , '/oauth2callback' )


get ( '/authorize' ) do
  # NOTE: Assumes the user is already authenticated to the app
  user_id = request . session [ 'user_id' ]
  credentials = authorizer . get_credentials ( user_id , request )
  if credentials . nil?
    redirect authorizer . get_authorization_url ( login_hint : user_id , request : request )
  end
  # Credentials are valid, can call APIs
  # ...
end

get ( '/oauth2callback' ) do
  target_url = Google :: Auth :: WebUserAuthorizer . handle_auth_callback_deferred (
    request )
  redirect target_url
end

Ejemplo (Web con PKCE)

Proof Key for Code Exchange (PKCE) es un RFC que tiene como objetivo evitar que procesos maliciosos del sistema operativo se apropien de un intercambio OAUTH 2.0. PKCE mitiga la vulnerabilidad anterior al incluir los parámetros code_challenge y code_challenge_method en la Solicitud de autorización y un parámetro code_verifier en la Solicitud de token de acceso.

 require 'googleauth'
require 'googleauth/web_user_authorizer'
require 'googleauth/stores/redis_token_store'
require 'redis'

client_id = Google :: Auth :: ClientId . from_file ( '/path/to/client_secrets.json' )
scope = [ 'https://www.googleapis.com/auth/drive' ]
token_store = Google :: Auth :: Stores :: RedisTokenStore . new ( redis : Redis . new )
authorizer = Google :: Auth :: WebUserAuthorizer . new (
  client_id , scope , token_store , '/oauth2callback' )


get ( '/authorize' ) do
  # NOTE: Assumes the user is already authenticated to the app
  user_id = request . session [ 'user_id' ]
  # User needs to take care of generating the code_verifier and storing it in
  # the session.
  request . session [ 'code_verifier' ] ||= Google :: Auth :: WebUserAuthorizer . generate_code_verifier
  authorizer . code_verifier = request . session [ 'code_verifier' ]
  credentials = authorizer . get_credentials ( user_id , request )
  if credentials . nil?
    redirect authorizer . get_authorization_url ( login_hint : user_id , request : request )
  end
  # Credentials are valid, can call APIs
  # ...
end

get ( '/oauth2callback' ) do
  target_url = Google :: Auth :: WebUserAuthorizer . handle_auth_callback_deferred (
    request )
  redirect target_url
end

Ejemplo (línea de comando) [obsoleto]

El flujo OOB de autenticación de Google se suspendió el 31 de enero de 2023. El flujo OOB es un flujo heredado que ya no se considera seguro. Para continuar usando Google Auth, migre sus aplicaciones a un flujo más seguro. Para obtener más información sobre cómo hacer esto, consulte esta guía de migración OOB.

 require 'googleauth'
require 'googleauth/stores/file_token_store'

OOB_URI = 'urn:ietf:wg:oauth:2.0:oob'

scope = 'https://www.googleapis.com/auth/drive'
client_id = Google :: Auth :: ClientId . from_file ( '/path/to/client_secrets.json' )
token_store = Google :: Auth :: Stores :: FileTokenStore . new (
  :file => '/path/to/tokens.yaml' )
authorizer = Google :: Auth :: UserAuthorizer . new ( client_id , scope , token_store )

user_id = ENV [ 'USER' ]
credentials = authorizer . get_credentials ( user_id )
if credentials . nil?
  url = authorizer . get_authorization_url ( base_url : OOB_URI )
  puts "Open #{ url } in your browser and enter the resulting code:"
  code = gets
  credentials = authorizer . get_and_store_credentials_from_code (
    user_id : user_id , code : code , base_url : OOB_URI )
end

# OK to use credentials

Ejemplo (cuenta de servicio)

 scope = 'https://www.googleapis.com/auth/androidpublisher'

authorizer = Google :: Auth :: ServiceAccountCredentials . make_creds (
  json_key_io : File . open ( '/path/to/service_account_json_key.json' ) ,
  scope : scope )

authorizer . fetch_access_token!

También puede utilizar un archivo de claves JSON configurando la variable de entorno GOOGLE_APPLICATION_CREDENTIALS .

 export GOOGLE_APPLICATION_CREDENTIALS=/path/to/service_account_json_key.json

 require 'googleauth'
require 'google/apis/drive_v3'

Drive = :: Google :: Apis :: DriveV3
drive = Drive :: DriveService . new

scope = 'https://www.googleapis.com/auth/drive'

authorizer = Google :: Auth :: ServiceAccountCredentials . from_env ( scope : scope )
drive . authorization = authorizer

list_files = drive . list_files ( )

OAuth de tres patas con una cuenta de servicio

Esto es similar a la autorización normal de la cuenta de servicio (consulte esta respuesta para obtener más detalles sobre las diferencias), pero deberá indicar a qué usuario se hace pasar su cuenta de servicio actualizando manualmente el sub .

 scope = 'https://www.googleapis.com/auth/androidpublisher'

authorizer = Google :: Auth :: ServiceAccountCredentials . make_creds (
  json_key_io : File . open ( '/path/to/service_account_json_key.json' ) ,
  scope : scope
)
authorizer . update! ( sub : "[email protected]" )

authorizer . fetch_access_token!

Ejemplo (variables de entorno)

 export GOOGLE_ACCOUNT_TYPE=service_account
export GOOGLE_CLIENT_ID=000000000000000000000
export [email protected]
export GOOGLE_PRIVATE_KEY= " -----BEGIN PRIVATE KEY-----n...n-----END PRIVATE KEY-----n "

 require 'googleauth'
require 'google/apis/drive_v3'

Drive = :: Google :: Apis :: DriveV3
drive = Drive :: DriveService . new

# Auths with ENV vars:
# "GOOGLE_CLIENT_ID",
# "GOOGLE_CLIENT_EMAIL",
# "GOOGLE_ACCOUNT_TYPE", 
# "GOOGLE_PRIVATE_KEY"
auth = :: Google :: Auth :: ServiceAccountCredentials
  . make_creds ( scope : 'https://www.googleapis.com/auth/drive' )
drive . authorization = auth

list_files = drive . list_files ( )

Almacenamiento

Los autorizadores requieren una instancia de almacenamiento para gestionar la persistencia a largo plazo de los tokens de acceso y actualización. Se incluyen dos implementaciones de almacenamiento:

Google::Auth::Tiendas::FileTokenStore
Google::Auth::Tiendas::RedisTokenStore

También se pueden utilizar implementaciones de almacenamiento personalizadas. Consulte token_store.rb para obtener detalles adicionales.

Versiones de Ruby compatibles

Esta biblioteca es compatible con Ruby 2.6+.

Google proporciona soporte oficial para las versiones de Ruby que cuentan con soporte activo de Ruby Core, es decir, versiones de Ruby que se encuentran en mantenimiento normal o en mantenimiento de seguridad, y no al final de su vida útil. Es posible que las versiones anteriores de Ruby aún funcionen, pero no son compatibles y no se recomiendan. Consulte https://www.ruby-lang.org/en/downloads/branches/ para obtener detalles sobre el programa de soporte de Ruby.