GCP: Google Cloud Storage

Google Cloud Storage (GCS) es: un servicio de almacenamiento en la nube ofrecido por Google Cloud Platform (GCP). Proporciona un almacenamiento escalable y duradero para datos no estructurados, como objetos, archivos y datos multimedia, permitiendo el acceso rápido y seguro a ellos desde cualquier lugar del mundo a través de internet.

Algunas características y funcionalidades que posee para gestionar y procesar datos de forma eficiente:

1. Escalabilidad: GCS puede manejar grandes volúmenes de datos y escalarse automáticamente según las necesidades de tu aplicación.
2. Durabilidad: Los datos almacenados en GCS están protegidos contra pérdidas mediante la replicación y distribución en múltiples ubicaciones geográficas.
3. Seguridad: GCS ofrece controles de acceso granulares, cifrado de datos en reposo y en tránsito, y funciones de auditoría para garantizar la seguridad y la conformidad con las regulaciones.
4. Integración con otros servicios de GCP: GCS se integra estrechamente con otros servicios de Google Cloud Platform, como BigQuery, Compute Engine y App Engine, facilitando la construcción de aplicaciones y flujos de trabajo en la nube.
5. Almacenamiento multi-nivel: GCS ofrece diferentes clases de almacenamiento para adaptarse a las necesidades de rendimiento y costo de tus datos, incluyendo almacenamiento estándar, almacenamiento de acceso frecuente, almacenamiento de acceso casi instantáneo y almacenamiento de archivo de largo plazo.
6. Acceso desde cualquier lugar: Los datos almacenados en GCS pueden ser accesibles desde cualquier lugar del mundo a través de internet, lo que facilita su uso en aplicaciones distribuidas globalmente.

Google Cloud Storage y Java

Para poder usarlo en nuestros proyectos, debemos descargar la librería oficial.

En la página oficial podemos ver varios ejemplos de cómo usarlo.

QuickstartSample.java

package com.codemonkey.main;


// Imports the Google Cloud client library
import com.google.cloud.storage.Bucket;
import com.google.cloud.storage.BucketInfo;
import com.google.cloud.storage.Storage;
import com.google.cloud.storage.StorageOptions;

public class QuickstartSample {

  public static void main(String... args) throws Exception {
    // Instantiates a client
    Storage storage = StorageOptions.getDefaultInstance().getService();

    // The name for the new bucket
    String bucketName = args[0]; // "my-new-bucket";

    // Creates the new bucket
    Bucket bucket = storage.create(BucketInfo.of(bucketName));

    System.out.printf("Bucket %s created.%n", bucket.getName());
  }
}

Como se puede observar, este programa crea un nuevo bucket en Google Cloud Storage utilizando el nombre proporcionado como argumento en la línea de comandos.

Pero... ¿Qué es un bucket?

Un bucket es un contenedor fundamental en Google Cloud Storage (GCS) utilizado para almacenar objetos. En términos simples, un bucket es similar a una carpeta en un sistema de archivos, pero en lugar de almacenar archivos, almacena objetos.

Los buckets de Google Cloud Storage son una parte fundamental de la plataforma de Google Cloud Platform (GCP) y se utilizan para almacenar una amplia variedad de datos, incluyendo archivos estáticos para sitios web, copias de seguridad de bases de datos, archivos multimedia, datos de análisis y mucho más.

Algunas características de los buckets:

1. Universalmente únicos: Cada bucket debe tener un nombre único a nivel mundial. Esto significa que el nombre de tu bucket debe ser único entre todos los buckets existentes en Google Cloud Storage, no solo dentro de tu proyecto.
2. Jerarquía de almacenamiento: Los buckets pueden contener objetos y pueden estar organizados jerárquicamente. Los nombres de los objetos dentro de un bucket pueden incluir "/" para simular una estructura de directorios.
3. Propiedades de almacenamiento: Los buckets tienen propiedades asociadas, como la ubicación regional o multirregional, que determinan dónde se almacenan físicamente los datos del bucket.
4. Control de acceso: Puedes configurar políticas de control de acceso para controlar quién puede acceder y qué pueden hacer con los objetos dentro de un bucket.
5. Durabilidad y disponibilidad: Los datos almacenados en un bucket de GCS son altamente duraderos y están disponibles. GCS replica automáticamente los datos en múltiples ubicaciones para protegerlos contra fallos y garantizar su integridad y disponibilidad.

Ejemplo. Un programa Java para realizar operaciones simples como subir un archivo, descargar un archivo y enumerar los archivos en un bucket

GCSExample.java

package com.codemonkey.main;


import com.google.cloud.storage.Bucket;
import com.google.cloud.storage.BucketInfo;
import com.google.cloud.storage.Storage;
import com.google.cloud.storage.StorageOptions;
import com.google.cloud.storage.Storage.BlobListOption;
import com.google.cloud.storage.Storage.BlobSourceOption;
import com.google.cloud.storage.Blob;
import com.google.cloud.storage.BlobId;

import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.InputStream;
import java.io.OutputStream;
import java.util.Iterator;

public class GCSExample {

    private static final String PROJECT_ID = "tu_proyecto";
    private static final String BUCKET_NAME = "tu_bucket";

    public static void main(String[] args) {
        // Crea una instancia de Storage
        Storage storage = StorageOptions.newBuilder().setProjectId(PROJECT_ID).build().getService();

        // Sube un archivo a un bucket
        uploadFile(storage, "archivo_local.txt", "archivo_en_gcs.txt");

        // Descarga un archivo de un bucket
        downloadFile(storage, "archivo_en_gcs.txt", "archivo_descargado.txt");

        // Enumera los archivos en un bucket
        listFiles(storage);
    }

    public static void uploadFile(Storage storage, String localFilePath, String cloudStorageFilePath) {
        try {
            BlobId blobId = BlobId.of(BUCKET_NAME, cloudStorageFilePath);
            BlobInfo blobInfo = BlobInfo.newBuilder(blobId).build();
            storage.create(blobInfo, new FileInputStream(localFilePath));
            System.out.println("Archivo subido correctamente a Cloud Storage.");
        } catch (Exception e) {
            System.out.println("Error al subir el archivo a Cloud Storage: " + e.getMessage());
            e.printStackTrace();
        }
    }

    public static void downloadFile(Storage storage, String cloudStorageFilePath, String localFilePath) {
        try {
            Blob blob = storage.get(BUCKET_NAME, cloudStorageFilePath);
            blob.downloadTo(new FileOutputStream(localFilePath));
            System.out.println("Archivo descargado correctamente desde Cloud Storage.");
        } catch (Exception e) {
            System.out.println("Error al descargar el archivo desde Cloud Storage: " + e.getMessage());
            e.printStackTrace();
        }
    }

    public static void listFiles(Storage storage) {
        try {
            Bucket bucket = storage.get(BUCKET_NAME);
            Iterator<Blob> blobs = bucket.list().iterateAll().iterator();
            System.out.println("Archivos en el bucket " + BUCKET_NAME + ":");
            while (blobs.hasNext()) {
                Blob blob = blobs.next();
                System.out.println(blob.getName());
            }
        } catch (Exception e) {
            System.out.println("Error al listar archivos en el bucket: " + e.getMessage());
            e.printStackTrace();
        }
    }
}

A menudo se puede usar a la par con BigQuery.

Ejemplo.Cómo cargar datos desde Google Cloud Storage a BigQuery.

BigQueryAndGCSExample.java

package com.codemonkey.main;

/**
*
* @author Codemonkey Junior
*/

import com.google.cloud.bigquery.BigQuery;
import com.google.cloud.bigquery.BigQueryOptions;
import com.google.cloud.bigquery.Dataset;
import com.google.cloud.bigquery.DatasetId;
import com.google.cloud.bigquery.Job;
import com.google.cloud.bigquery.JobInfo;
import com.google.cloud.bigquery.LoadJobConfiguration;
import com.google.cloud.storage.Storage;
import com.google.cloud.storage.StorageOptions;

public class BigQueryAndGCSExample {

    private static final String PROJECT_ID = "tu_proyecto";
    private static final String BUCKET_NAME = "tu_bucket";
    private static final String DATASET_ID = "tu_dataset";
    private static final String TABLE_NAME = "tu_tabla";
    private static final String FILE_PATH = "gs://tu_bucket/ruta/al/archivo.csv";

    public static void main(String[] args) {
        BigQuery bigquery = BigQueryOptions.getDefaultInstance().getService();
        Storage storage = StorageOptions.getDefaultInstance().getService();

        // Define el ID del dataset y la tabla de BigQuery
        DatasetId datasetId = DatasetId.of(PROJECT_ID, DATASET_ID);
        String tableName = TABLE_NAME;

        // Configura la configuración de carga de datos para BigQuery
        LoadJobConfiguration loadConfig = LoadJobConfiguration.newBuilder(datasetId.getTable(tableName), FILE_PATH)
                .setFormatOptions(FormatOptions.csv())
                .setAutodetect(true)
                .build();

        // Crea y ejecuta el trabajo de carga de datos
        Job job = bigquery.create(JobInfo.of(loadConfig));
        try {
            job = job.waitFor();
            if (job.isDone() && job.getStatus().getError() == null) {
                System.out.println("Datos cargados correctamente desde Google Cloud Storage a BigQuery.");
            } else {
                System.out.println("Error al cargar datos desde Google Cloud Storage a BigQuery: " + job.getStatus().getError());
            }
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

Ejemplo. Subir un archivo txt a una tabla de BigQuery. Para esto usaremos tanto Google Cloud Storage como Google Cloud BigQuery.

SubirTxtABigQuery.java

package main;

import com.google.cloud.bigquery.*;
import com.google.cloud.storage.*;

import java.io.*;
import java.nio.file.Files;
import java.nio.file.Paths;

public class SubirTxtABigQuery{

    public static void main(String[] args) throws IOException, InterruptedException {
        // Configurar el entorno
        BigQuery bigquery = BigQueryOptions.getDefaultInstance().getService();
        Storage storage = StorageOptions.getDefaultInstance().getService();

        // Preparar el archivo y la tabla
        String datasetName = "com.dev";
        String tableName = "tabla";
        String bucketName = "mibucket";
        String fileName = "miarchivo.txt";
        String filePath = "path/to/your/miarchivo.txt";

        // Crear la tabla en BigQuery si no existe
        TableId tableId = TableId.of(datasetName, tableName);
        if (!bigquery.getTable(tableId).exists()) {
            Schema schema = Schema.of(Field.of("column_name", LegacySQLTypeName.STRING));
            bigquery.create(TableInfo.of(tableId, StandardTableDefinition.of(schema)));
        }

        // Cargar el archivo en Google Cloud Storage
        BlobId blobId = BlobId.of(bucketName, fileName);
        BlobInfo blobInfo = BlobInfo.newBuilder(blobId).build();
        storage.create(blobInfo, Files.readAllBytes(Paths.get(filePath)));

        //  Cargar los datos del archivo en la tabla de BigQuery
        String uri = "gs://" + bucketName + "/" + fileName;
        Job job = bigquery.load(LoadJobConfiguration.newBuilder(tableId, uri, FormatOptions.csv()).build());
        job = job.waitFor();

        if (job != null && job.getStatus().getError() == null) {
            System.out.println("Archivo TXT cargado correctamente en la tabla de BigQuery.");
        } else {
            System.out.println("Error al cargar el archivo TXT en la tabla de BigQuery: " + job.getStatus().getError());
        }
    }
}

En este ejemplo suponemos que el archivo txt concuerda con el formato de la tabla donde queremos cargar los datos.

Más ejemplos en próximas entregas.

Enlaces:

https://cloud.google.com/storage/docs/reference/libraries