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 truncada 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.

Habilita Google Storage Transfer API.

Habilita la 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. App Engine y Compute Engine tienen cuentas de servicio integradas que puedes usar, o bien puedes crear una credencial de servicio en Google Cloud 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 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.

El código también funciona con tu emulador local de App Engine, siempre que uses Google Cloud CLI (mvn gcloud:run), mediante una cuenta de servicio y con la configuración de la variable de entorno GOOGLE_APPLICATION_CREDENTIALS.

Para obtener más información, consulta la sección Host local o de terceros.

Aplicación de Compute Engine

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

Configura tu instancia para usar cuentas de servicio y agrega el alcance que se indica en la sección Alcance de la autorización.

Si deseas obtener más información, consulta Configura el alcance del acceso de la cuenta de servicio para las instancias en la documentación de Compute Engine.

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 Autentícate como cuenta de servicio.

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

Puede usar el siguiente código de muestra para crear un cliente del Servicio de transferencia de almacenamiento en cualquiera de los entornos descritos en 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.

A la cuenta de servicio se le debe asignar una de las siguientes funciones:

Puedes verificar en la página de permisos de tu proyecto.

Java

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

storage/storage-transfer/src/main/java/com/google/cloud/storage/storagetransfer/samples/CreateTransferClient.java 
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.auth.http.HttpCredentialsAdapter;
import com.google.auth.oauth2.GoogleCredentials;
import com.google.common.base.Preconditions;
import java.io.IOException;

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

  /**
   * 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();
    GoogleCredentials credential = GoogleCredentials.getApplicationDefault();
    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, GoogleCredentials 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 HttpCredentialsAdapter(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.

storage/transfer_service/create_client.py 
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ódigo para controlar los reintentos con una estrategia de retirada exponencial truncada.

Java

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

storage/storage-transfer/src/main/java/com/google/cloud/storage/storagetransfer/samples/RetryHttpInitializerWrapper.java 
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

storage/transfer_service/get_transfer_job_with_retries.py 

"""Command-line sample that gets a transfer job using retries
"""

import googleapiclient.discovery

def get_transfer_job_with_retries(project_id, job_name, retries):
    """Check the latest transfer operation associated with a transfer job."""
    storagetransfer = googleapiclient.discovery.build("storagetransfer", "v1")

    transferJob = (
        storagetransfer.transferJobs()
        .get(projectId=project_id, jobName=job_name)
        .execute(num_retries=retries)
    )
    print(
        "Fetched transfer job: "
        + transferJob.get("name")
        + " using {} retries".format(retries)
    )