Crea un cliente del Servicio de transferencia de almacenamiento para una biblioteca de API de Google

Antes de que puedas efectuar solicitudes al Servicio de transferencia de almacenamiento, debes asegurarte de que las API del Servicio de transferencia de almacenamiento estén habilitadas en tu proyecto, y de que tu aplicación se encuentre configurada para su autorización a través del protocolo OAuth 2.0. Te recomendamos que implementes la retirada exponencial a fin de controlar los reintentos en caso de fallas en las solicitudes.

Habilita el servicio

Para acceder al Servicio de transferencia de almacenamiento mediante la biblioteca de API de Google, o de forma directa mediante la API del Servicio de transferencia de almacenamiento, se requiere que habilites la API del Servicio de transferencia de almacenamiento. Para hacerlo, sigue estos pasos: Habilita las Google Storage Transfer API necesarias.

Habilita las API

Flujo de autenticación

Debido a que todas las operaciones del Servicio de transferencia de almacenamiento se realizan sin necesidad de intervención humana o de consentimiento del usuario, el mejor flujo de autenticación para una aplicación del Servicio de transferencia de almacenamiento es de servidor a servidor, mediante una cuenta de servicio. Google App Engine y Google Compute Engine tienen cuentas de servicio integradas que puedes aprovechar, o puedes crear una credencial de servicio en Google Cloud Platform Console.

Cuando usas una cuenta de servicio, las bibliotecas cliente de las API de Google controlan el proceso de autenticación y autorización por ti, en las siguientes situaciones:

Aplicación de Google App Engine

Si tu aplicación se ejecuta en App Engine, es autenticada con la cuenta de servicio predeterminada de tu aplicación de App Engine.

Nota: El código también funciona con tu emulador local de App Engine mientras uses el SDK de Google Cloud (mvn gcloud:run), mediante una cuenta de servicio y con la configuración de la variable de entorno GOOGLE_APPLICATION_CREDENTIALS. Consulta Host local o de terceros para obtener más detalles.

Aplicación de Google Compute Engine

Si tu aplicación se ejecuta en una instancia de Google Compute Engine, se autentica con la cuenta de servicio predeterminada de Compute Engine asociada con el proyecto.

Host local o de terceros

Si tienes un cliente local en ejecución o si ejecutas tu programa en un entorno que no pertenece a Google Cloud, crea una cuenta de servicio nueva, descarga su archivo de claves JSON y, a continuación, configura la variable de entorno GOOGLE_APPLICATION_CREDENTIALS para que se oriente al archivo de claves JSON. Para obtener más información, consulta Cómo funcionan las credenciales predeterminadas de la aplicación.

Alcance de la autorización

Las aplicaciones que tienen acceso al Servicio de transferencia de almacenamiento a través de OAuth 2.0 deben especificar el alcance de la autorización de cloud-platform.

Alcance Significado
https://www.googleapis.com/auth/cloud-platform Acceso completo

Crea un cliente

Puedes usar el código de muestra siguiente para crear un cliente del Servicio de transferencia de almacenamiento en cualquiera de los entornos mencionados en el flujo de autenticación. Debido a que en el código se usan credenciales predeterminadas de la aplicación de Google, el código selecciona la cuenta de servicio adecuada para su uso.

Java

En esta muestra se usa la biblioteca cliente de las API de Google para Java. La clase predeterminada RetryHttpInitializerWrapper se describe en la sección de Control de reintentos.

package com.google.cloud.storage.storagetransfer.samples;

import com.google.api.client.googleapis.auth.oauth2.GoogleCredential;
import com.google.api.client.googleapis.util.Utils;
import com.google.api.client.http.HttpRequestInitializer;
import com.google.api.client.http.HttpTransport;
import com.google.api.client.json.JsonFactory;
import com.google.api.services.storagetransfer.v1.Storagetransfer;
import com.google.api.services.storagetransfer.v1.StoragetransferScopes;
import com.google.common.base.Preconditions;
import java.io.IOException;

/**
 * Create a client to make calls to Storage Transfer API.
 */
public final class TransferClientCreator {

  /**
   * Create a Storage Transfer client using application default credentials and other default
   * settings.
   *
   * @return a Storage Transfer client
   * @throws IOException
   *           there was an error obtaining application default credentials
   */
  public static Storagetransfer createStorageTransferClient() throws IOException {
    HttpTransport httpTransport = Utils.getDefaultTransport();
    JsonFactory jsonFactory = Utils.getDefaultJsonFactory();
    GoogleCredential credential =
        GoogleCredential.getApplicationDefault(httpTransport, jsonFactory);
    return createStorageTransferClient(httpTransport, jsonFactory, credential);
  }

  /**
   * Create a Storage Transfer client using user-supplied credentials and other settings.
   *
   * @param httpTransport
   *          a user-supplied HttpTransport
   * @param jsonFactory
   *          a user-supplied JsonFactory
   * @param credential
   *          a user-supplied Google credential
   * @return a Storage Transfer client
   */
  public static Storagetransfer createStorageTransferClient(
      HttpTransport httpTransport, JsonFactory jsonFactory, GoogleCredential credential) {
    Preconditions.checkNotNull(httpTransport);
    Preconditions.checkNotNull(jsonFactory);
    Preconditions.checkNotNull(credential);

    // In some cases, you need to add the scope explicitly.
    if (credential.createScopedRequired()) {
      credential = credential.createScoped(StoragetransferScopes.all());
    }
    // Please use custom HttpRequestInitializer for automatic
    // retry upon failures. We provide a simple reference
    // implementation in the "Retry Handling" section.
    HttpRequestInitializer initializer = new RetryHttpInitializerWrapper(credential);
    return new Storagetransfer.Builder(httpTransport, jsonFactory, initializer)
        .setApplicationName("storagetransfer-sample")
        .build();
  }
}

Python

En esta muestra se usa la biblioteca cliente de las API de Google para Python.

import googleapiclient.discovery

def create_transfer_client():
    return googleapiclient.discovery.build('storagetransfer', 'v1')

Control de reintentos

En este caso de fallas de RPC, debes implementar códigos para controlar los reintentos con una estrategia de retirada exponencial.

Java

En esta muestra se usa la biblioteca cliente de las API de Google para Java. La clase RetryHttpInitializerWrapper controla los reintentos por ti.

package com.google.cloud.storage.storagetransfer.samples;

import com.google.api.client.auth.oauth2.Credential;
import com.google.api.client.http.HttpBackOffIOExceptionHandler;
import com.google.api.client.http.HttpBackOffUnsuccessfulResponseHandler;
import com.google.api.client.http.HttpRequest;
import com.google.api.client.http.HttpRequestInitializer;
import com.google.api.client.http.HttpResponse;
import com.google.api.client.http.HttpUnsuccessfulResponseHandler;
import com.google.api.client.util.ExponentialBackOff;
import com.google.api.client.util.Sleeper;
import com.google.common.base.Preconditions;
import java.io.IOException;
import java.util.logging.Logger;

/**
 * RetryHttpInitializerWrapper will automatically retry upon RPC failures, preserving the
 * auto-refresh behavior of the Google Credentials.
 */
public class RetryHttpInitializerWrapper implements HttpRequestInitializer {

  private static final Logger LOG = Logger.getLogger(RetryHttpInitializerWrapper.class.getName());
  private final Credential wrappedCredential;
  private final Sleeper sleeper;
  private static final int MILLIS_PER_MINUTE = 60 * 1000;

  /**
   * A constructor using the default Sleeper.
   *
   * @param wrappedCredential
   *          the credential used to authenticate with a Google Cloud Platform project
   */
  public RetryHttpInitializerWrapper(Credential wrappedCredential) {
    this(wrappedCredential, Sleeper.DEFAULT);
  }

  /**
   * A constructor used only for testing.
   *
   * @param wrappedCredential
   *          the credential used to authenticate with a Google Cloud Platform project
   * @param sleeper
   *          a user-supplied Sleeper
   */
  RetryHttpInitializerWrapper(Credential wrappedCredential, Sleeper sleeper) {
    this.wrappedCredential = Preconditions.checkNotNull(wrappedCredential);
    this.sleeper = sleeper;
  }

  /**
   * Initialize an HttpRequest.
   *
   * @param request
   *          an HttpRequest that should be initialized
   */
  public void initialize(HttpRequest request) {
    request.setReadTimeout(2 * MILLIS_PER_MINUTE); // 2 minutes read timeout
    final HttpUnsuccessfulResponseHandler backoffHandler =
        new HttpBackOffUnsuccessfulResponseHandler(new ExponentialBackOff()).setSleeper(sleeper);
    request.setInterceptor(wrappedCredential);
    request.setUnsuccessfulResponseHandler(
        new HttpUnsuccessfulResponseHandler() {
          public boolean handleResponse(
              final HttpRequest request, final HttpResponse response, final boolean supportsRetry)
              throws IOException {
            if (wrappedCredential.handleResponse(request, response, supportsRetry)) {
              // If credential decides it can handle it, the return code or message indicated
              // something specific to authentication, and no backoff is desired.
              return true;
            } else if (backoffHandler.handleResponse(request, response, supportsRetry)) {
              // Otherwise, we defer to the judgement of our internal backoff handler.
              LOG.info("Retrying " + request.getUrl().toString());
              return true;
            } else {
              return false;
            }
          }
        });
    request.setIOExceptionHandler(
        new HttpBackOffIOExceptionHandler(new ExponentialBackOff()).setSleeper(sleeper));
  }
}

Python

Puedes pasar el argumento num_retries=n al método execute de la biblioteca para hacer reintentos con retirada exponencial en relación con fallas que se pueden reintentar.

resp = client.projects().subscriptions().pull(
subscription=subscription, body=body).execute(num_retries=3)
¿Te ha resultado útil esta página? Enviar comentarios:

Enviar comentarios sobre...

Documentación del Servicio de transferencia de almacenamiento de Cloud