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

GCP: Google Cloud BigQuery

BigQuery,a groso modo, es:

• Un almacén de datos empresariales.
• Una plataforma de análisis de datos altamente escalable que ofrece una amplia gama de operaciones para ayudarte a analizar y procesar grandes conjuntos de datos de manera eficiente.

Algunas operaciones que se puede realizar con BigQuery:

1. Consulta de datos: Puedes ejecutar consultas SQL complejas para extraer datos de tus conjuntos de datos y realizar análisis avanzados.
2. Análisis de datos en tiempo real: BigQuery admite consultas en tiempo real sobre datos de streaming, lo que te permite analizar y visualizar datos en tiempo real a medida que llegan.
3. Análisis geoespacial: BigQuery incluye funciones y operaciones para realizar análisis geoespaciales, como cálculos de distancia, intersecciones espaciales y agrupaciones geográficas.
4. Operaciones de agregación: Puedes realizar operaciones de agregación como SUM, AVG, COUNT, MAX y MIN en tus datos para resumir la información y obtener insights.
5. Procesamiento de texto: BigQuery proporciona funciones y operadores para procesar datos de texto, como búsquedas de patrones, análisis de sentimientos y extracción de entidades.
6. Integración con herramientas de análisis y visualización: Puedes integrar BigQuery con herramientas de análisis y visualización de datos populares como Google Data Studio, Tableau y Power BI para crear paneles interactivos y visualizaciones de datos.
7. Machine Learning: BigQuery ML te permite construir y entrenar modelos de aprendizaje automático directamente en tus datos almacenados en BigQuery, sin necesidad de moverlos a otro lugar.
8. Carga y exportación de datos: Puedes cargar datos en BigQuery desde archivos locales, Google Cloud Storage, servicios de streaming como Pub/Sub y otras fuentes de datos. También puedes exportar datos desde BigQuery a diferentes formatos de archivo y servicios de almacenamiento.
9. Seguridad y control de acceso: BigQuery ofrece controles de acceso granulares y opciones de cifrado para proteger tus datos y garantizar la conformidad con las normativas de privacidad.
10. Administración y monitoreo: BigQuery proporciona herramientas para administrar y monitorear tus recursos, consultas y cargas de trabajo, como el tablero de control de BigQuery y Cloud Monitoring.

Ejemplo de procesamiento de texto con BigQuery:

SELECT word, COUNT(*) AS word_count
FROM (
  SELECT SPLIT(LOWER(descripcion), ' ') AS words
  FROM `tu_proyecto.tu_dataset.tu_tabla`
), UNNEST(words) AS word
WHERE LENGTH(word) > 3 -- Considera solo palabras de al menos 4 caracteres
GROUP BY word
ORDER BY word_count DESC
LIMIT 10; -- Limita los resultados a las 10 palabras más comunes

Suponiendo que tenemos una tabla en BigQuery que contiene un campo de texto llamado ``descripcion``. Queremos realizar un análisis básico del texto para contar las palabras más comunes en esa descripción.

Ejemplo de conexión y verificación con BigQuery:

BigQueryConnectionVerification.java

package com.codemonkey.main;
/**
* @uthor Codemonkey Junior
*
*/

import com.google.cloud.bigquery.BigQuery;
import com.google.cloud.bigquery.BigQueryOptions;

public class BigQueryConnectionVerification {
    
    public static void main(String[] args) {
        try {
            // Intenta crear una instancia de BigQuery
            BigQuery bigquery = BigQueryOptions.getDefaultInstance().getService();
            
            // Si no se produce ninguna excepción, la conexión se ha establecido correctamente
            System.out.println("La conexión a BigQuery se ha establecido correctamente.");
        } catch (Exception e) {
            // Si se produce una excepción, muestra un mensaje de error
            System.out.println("Error al verificar la conexión a BigQuery: " + e.getMessage());
            e.printStackTrace();
        }
    }
}

BigQuery y Java

Para esto debemos utilizar la biblioteca oficial de BigQuery para Java.

Ejemplo de consulta con Java y BigQuery.

BigQueryWordCount.java

package com.codemonkey.main;
/**
* @uthor Codemonkey Junior
*
*/

import com.google.cloud.bigquery.*;

public class BigQueryWordCount {


    public static void main(String[] args) {
        // Crea una instancia de BigQuery
        BigQuery bigquery = BigQueryOptions.getDefaultInstance().getService();

        // Define la consulta SQL
        String query = 
            "SELECT word, COUNT(*) AS word_count " +
            "FROM ( " +
            "  SELECT SPLIT(LOWER(descripcion), ' ') AS words " +
            "  FROM `tu_proyecto.tu_dataset.tu_tabla` " +
            "), UNNEST(words) AS word " +
            "WHERE LENGTH(word) > 3 " +
            "GROUP BY word " +
            "ORDER BY word_count DESC " +
            "LIMIT 10";

        // Ejecuta la consulta
        try {
            QueryJobConfiguration queryConfig = QueryJobConfiguration.newBuilder(query).build();
            TableResult result = bigquery.query(queryConfig);

            // Imprime los resultados
            System.out.println("Palabra\t\tConteo");
            for (FieldValueList row : result.iterateAll()) {
                String word = row.get("word").getStringValue();
                long wordCount = row.get("word_count").getLongValue();
                System.out.printf("%s\t\t%d%n", word, wordCount);
            }
        } catch (BigQueryException e) {
            System.out.println("Error al ejecutar la consulta: " + e.getMessage());
            e.printStackTrace();
        }
    }
}

En este código, primero creamos una instancia de BigQuery. Luego, definimos la consulta SQL y la ejecutamos utilizando bigquery.query(). Iteramos sobre los resultados y los imprimimos en la consola. Asegúrate de reemplazar "tu_proyecto.tu_dataset.tu_tabla" con el nombre de tu proyecto, conjunto de datos y tabla reales en BigQuery.

BigQuery se ha convertido en una herramienta muy usada en la actualidad. El sitio oficial cuenta con algunos ejemplos para poder aprender y usarlo en nuestros proyectos:

SimpleApp.java

package com.codemonkey.main;
/**
* @uthor Codemonkey Junior
*
*/

import com.google.cloud.bigquery.BigQuery;
import com.google.cloud.bigquery.BigQueryOptions;
import com.google.cloud.bigquery.FieldValueList;
import com.google.cloud.bigquery.Job;
import com.google.cloud.bigquery.JobId;
import com.google.cloud.bigquery.JobInfo;
import com.google.cloud.bigquery.QueryJobConfiguration;
import com.google.cloud.bigquery.TableResult;
import java.util.UUID;

public class SimpleApp {

  public static void main(String... args) throws Exception {
    BigQuery bigquery = BigQueryOptions.getDefaultInstance().getService();
    QueryJobConfiguration queryConfig =
        QueryJobConfiguration.newBuilder(
                "SELECT CONCAT('https://stackoverflow.com/questions/', "
                    + "CAST(id as STRING)) as url, view_count "
                    + "FROM `bigquery-public-data.stackoverflow.posts_questions` "
                    + "WHERE tags like '%google-bigquery%' "
                    + "ORDER BY view_count DESC "
                    + "LIMIT 10")
            // Use standard SQL syntax for queries.
            // See: https://cloud.google.com/bigquery/sql-reference/
            .setUseLegacySql(false)
            .build();

    // Create a job ID so that we can safely retry.
    JobId jobId = JobId.of(UUID.randomUUID().toString());
    Job queryJob = bigquery.create(JobInfo.newBuilder(queryConfig).setJobId(jobId).build());

    // Wait for the query to complete.
    queryJob = queryJob.waitFor();

    // Check for errors
    if (queryJob == null) {
      throw new RuntimeException("Job no longer exists");
    } else if (queryJob.getStatus().getError() != null) {
      // You can also look at queryJob.getStatus().getExecutionErrors() for all
      // errors, not just the latest one.
      throw new RuntimeException(queryJob.getStatus().getError().toString());
    }

    // Get the results.
    TableResult result = queryJob.getQueryResults();

    // Print all pages of the results.
    for (FieldValueList row : result.iterateAll()) {
      // String type
      String url = row.get("url").getStringValue();
      String viewCount = row.get("view_count").getStringValue();
      System.out.printf("%s : %s views\n", url, viewCount);
    }
  }
}

Más ejemplos en próximas entregas.

Enlaces:

https://cloud.google.com/bigquery

Microsoft Azure en un vistazo

Microsoft Azure es una plataforma de servicios en la nube ofrecida por Microsoft. Similar a Google Cloud Platform (GCP) y Amazon Web Services (AWS), Azure proporciona una amplia gama de servicios de computación en la nube, incluyendo almacenamiento, análisis, redes, bases de datos, inteligencia artificial, desarrollo de aplicaciones y más.

Algunos servicios que ofrece:

1. Azure Virtual Machines: Ofrece máquinas virtuales escalables y flexibles para ejecutar aplicaciones en la nube, con soporte para una variedad de sistemas operativos.
2. Azure Blob Storage: Proporciona almacenamiento de objetos seguro y altamente escalable para datos no estructurados, como archivos multimedia y documentos.
3. Azure SQL Database: Es un servicio de base de datos relacional completamente administrado que ofrece escalabilidad, seguridad y alta disponibilidad para aplicaciones críticas.
4. Azure App Service: Permite a los desarrolladores crear, implementar y escalar aplicaciones web y móviles de manera rápida y sencilla, sin preocuparse por la infraestructura subyacente.
5. Azure Kubernetes Service (AKS): Proporciona una plataforma de contenedores administrada basada en Kubernetes para desplegar, gestionar y escalar aplicaciones en contenedores de manera eficiente.
6. Azure Functions: Permite ejecutar código en la nube sin tener que preocuparse por la infraestructura subyacente, lo que facilita la creación de aplicaciones basadas en eventos y sin servidor.
7. Azure Cognitive Services: Ofrece una variedad de servicios de inteligencia artificial preentrenados, como reconocimiento de imágenes, procesamiento de lenguaje natural y análisis de sentimientos, para agregar funcionalidades avanzadas a las aplicaciones.
8. Azure DevOps: Proporciona herramientas para el desarrollo de software, incluyendo control de versiones, seguimiento de problemas, integración continua y entrega continua (CI/CD), para facilitar la colaboración en equipos de desarrollo.

En próximas entregas veremos más de este tema.

Enlaces:

https://azure.microsoft.com/

Google Cloud Platform (GCP) en un vistazo

GCP es, básicamente, un conjunto de servicios de computación en la nube ofrecidos por Google. Similar a Microsoft Azure de la malévola empresa Microsoft (broma) y AWS(el actual líder en este tipo de servicios) de Amazon. GCP comparte un tercero o a veces un segundo lugar en la posición de empresas que ofrecen servicios de cómputo en la nube. Entre sus múltiples y variados servicios podemos encontrar:

• Computación en la nube.
• Almacenamiento de datos en la nube.
• Redes en la nube.
• BigData y Análisis de Datos.
• I.A. y Machine Learning.
• Seguridad y cumplimiento.

GCP permite a las empresas y desarrolladores crear, implementar y escalar aplicaciones y servicios en la infraestructura global de Google, lo que les permite aprovechar la infraestructura y la tecnología de Google para sus propios fines.

Algunos de los principales servicios de Google Cloud Platform (GCP):

1. Compute Engine: Ofrece máquinas virtuales escalables y flexibles que permiten a los usuarios ejecutar aplicaciones en la infraestructura de Google.
2. App Engine: Es un entorno de desarrollo y alojamiento de aplicaciones totalmente administrado que escala automáticamente según la demanda de tráfico.
3. Google Kubernetes Engine (GKE): Proporciona una plataforma de contenedores administrada basada en Kubernetes para desplegar, gestionar y escalar aplicaciones en contenedores.
4. Cloud Storage: Es un servicio de almacenamiento en la nube altamente escalable y duradero que permite almacenar, acceder y compartir datos de forma segura y eficiente.
5. BigQuery: Es un servicio de análisis de datos completamente administrado que permite realizar consultas SQL sobre conjuntos de datos extremadamente grandes en tiempo real.
6. Cloud AI: Ofrece una amplia gama de herramientas y servicios de inteligencia artificial y aprendizaje automático, como Vision AI, Language AI y Video AI, para desarrollar aplicaciones inteligentes.
7. Cloud Firestore / Firebase: Una base de datos en tiempo real y plataforma de desarrollo de aplicaciones móviles que permite crear aplicaciones de alta calidad con una infraestructura de servidor completamente administrada.
8. Cloud Pub/Sub: Es un servicio de mensajería escalable y duradero que permite la ingestión y entrega de eventos entre componentes de aplicaciones distribuidas en tiempo real.

Cada uno de estos servicios está diseñado para proporcionar funcionalidades específicas que abordan diferentes necesidades en la nube, desde almacenamiento y análisis de datos hasta desarrollo de aplicaciones y servicios de inteligencia artificial

Enlaces:

https://cloud.google.com/