gRPC: una alternativa para servicios de alto rendimiento

gRPC (google Remote Procedure Calls) es un framework que nos sirve para realizar llamadas a procedimientos remotos.

Es de alto rendimiento. Multilenguaje (clientes y servidores). Además de tener un Streaming avanzado, lo que permite comunicaciones tipo: unary, server streaming, client streaming y streaming bidirectional.

Es ideal para microservicios gracias a su alto rendimiento, tipado fuerte y soporte multiplataforma.

Ya hemos hecho una comparativa entre otras alternativas como GraphQL:

gRPC y GraphQL

Usa Protocol buffers (*.proto) como mecanismo de serialización (y deserialización); el cual es un formato binario, más pequeño, rápido y sencillo que XML y JSON. Además de soportar diversos lenguajes como: Java, Python, Go, etc.

También usa HTTP/2 como protocolo de comunicación, el cual es una mejora del HTTP clásico. El cual prioriza solicitudes, permite la comprensión de encabezados, multiplexación (múltiples llamadas simultáneas) y tiene mayor seguridad.

Empezando con gRPC y .NET

Crearemos una aplicación Cliente-Servidor para mostrar el uso de gRPC. Como lenguaje base usaremos C# y la herramienta dotnet para crear los proyectos.

Quien ha trabajado con aplicaciones Cliente-Servidor podrá entender el flujo. Una aplicación Cliente hará solicitudes y el Servidor las atenderá.

Para este ejemplo necesitaremos crear:

• Un proyecto servidor. 
• Un proyecto cliente.

Empecemos con el Servidor

Creamos el proyecto servidor con soporte a gRPC:

$ dotnet new grpc -o GrpcServer
$ cd GrpcServer

Una vez ubicados en el directorio podemos ejecutarlo:

$ dotnet run

Abrimos el navegador en la ruta: http://localhost:5057

Si todo va bien, veremos un mensaje.

Continuemos con el Cliente

Creamos el proyecto cliente de tipo consola:

$ dotnet new console -o GrpcClient
$ cd GrpcClient

Una vez ubicados en el directorio del Cliente, copiamos el directorio y archivo Protos\greet.proto del proyecto Servidor al Cliente.

Editamos el archivo GrpcClient.csproj de para agregar el archivo copiado. De tal manera que quede de esta forma:

<Project Sdk="Microsoft.NET.Sdk">

  <PropertyGroup>
    <OutputType>Exe</OutputType>
    <TargetFramework>net10.0</TargetFramework>
    <ImplicitUsings>enable</ImplicitUsings>
    <Nullable>enable</Nullable>
  </PropertyGroup>

  <ItemGroup>
    <PackageReference Include="Google.Protobuf" Version="3.33.5" />
    <PackageReference Include="Grpc.Net.Client" Version="2.76.0" />
    <PackageReference Include="Grpc.Tools" Version="2.78.0">
      <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
      <PrivateAssets>all</PrivateAssets>
    </PackageReference>
	
	<Protobuf Include="Protos\greet.proto" GrpcServices="Client" />

  </ItemGroup>

</Project>

El archivo Protos\greet.proto es el siguiente:

syntax = "proto3";

option csharp_namespace = "Greet";

package greet;


service Greeter {
  rpc SayHello (HelloRequest) returns (HelloReply);
}

message HelloRequest {
  string name = 1;
}


message HelloReply {
  string message = 1;
}

Este archivo *.proto define el contrato de comunicación entre Cliente y Servidor en gRPC, y permite a un Cliente enviar un nombre y recibir un saludo como respuesta.

Compilamos y ejecutamos el proyecto Cliente:

$ dotnet build
$ dotnet run

Si todo va bien, veremos algo como esto en el Cliente:

Respuesta del servidor: Hello Code Monkey Junior

Y en el Servidor:

Usando la configuración de inicio de C:\Users\HP\Documents\pruebasCSharp\pruebasGRPC\GrpcServer\Properties\launchSettings.json...
Compilando...
info: Microsoft.Hosting.Lifetime[14]
      Now listening on: http://localhost:5057
info: Microsoft.Hosting.Lifetime[0]
      Application started. Press Ctrl+C to shut down.
info: Microsoft.Hosting.Lifetime[0]
      Hosting environment: Development
info: Microsoft.Hosting.Lifetime[0]
      Content root path: C:\Users\HP\Documents\pruebasCSharp\pruebasGRPC\GrpcServer
info: GrpcServer.Services.GreeterService[0]
      The message is received from Code Monkey Junior

Este solo es un ejemplo de gRPC. Aún falta saber más de Protobuf y HTTP/2 a profundidad.

Como mencionamos con gRPC podemos crear aplicaciones con diversos lenguajes de programación.

Por ejemplo, si tenemos un servidor creado en lenguaje de programación C# no habrá problema que clientes hechos en otros lenguajes como Java, Python, Go, etc. puedan realizar solicitudes y recibir respuestas.

Continuaremos con este tema en próximas entregas.

Enlaces:

https://grpc.io/
https://protobuf.dev/
https://dotnet.microsoft.com
https://alquimistadecodigo.blogspot.com/2024/05/grpc-protobuff-protocol-buffers.html
https://alquimistadecodigo.blogspot.com/2024/05/grpc-en-java-y-protobuff.html

Firebase Studio, el Visual Studio Code de Google

La "benevolente" y nada "maquiavélica" empresa Google ha lanzado una plataforma para programar: Firebase Studio.

Firebase Studio es un entorno de desarrollo basado en la nube, diseñado para acelerar la creación, prueba, implementación y ejecución de aplicaciones web y móviles de pila completa con inteligencia artificial (IA). Combina herramientas como Project IDX, Genkit y la IA de Gemini para ofrecer un espacio de trabajo colaborativo accesible desde cualquier navegador. Permite a desarrolladores y no programadores construir aplicaciones de calidad de producción, incluyendo APIs, backends, frontends y más, de forma rápida y eficiente.

Nota: Esto no es nada nuevo. Hace años existió una plataforma similar llamada: Cloud 9, ahora propiedad de AWS.

Características

• Prototipado con IA: Utiliza el App Prototyping agent con Gemini 2.0 Flash para generar aplicaciones web (actualmente con Next.js, con más frameworks en el futuro) a partir de descripciones en lenguaje natural, imágenes o bocetos, sin necesidad de programar. 
• Codificación con control total: Ofrece un entorno basado en Code OSS (similar a Visual Studio Code) con soporte para lenguajes como Java, Python, Node.js, Go, .NET, y frameworks como React, Angular, Vue.js, Flutter, entre otros. Incluye autocompletado, depuración y extensiones del Open VSX Registry. 
• Flexibilidad y personalización: Permite importar proyectos desde GitHub, GitLab o Bitbucket, usar plantillas predefinidas (más de 60 disponibles) o personalizar entornos con Nix. 
• Despliegue sencillo: Publica aplicaciones con un clic usando Firebase App Hosting, Cloud Run o infraestructura personalizada, con vistas previas instantáneas mediante URLs públicas o códigos QR. 
• Colaboración en tiempo real: Comparte espacios de trabajo mediante enlaces para que equipos trabajen simultáneamente, similar a Google Docs. 
• Asistencia de IA: Gemini en Firebase ayuda con tareas como generación de código, corrección de errores, pruebas, documentación y gestión de dependencias.

Modos de uso

• Sin código: Ideal para principiantes, permite crear prototipos describiendo la idea en lenguaje natural. 
• Codificación manual: Para desarrolladores avanzados que prefieren editar código directamente en un IDE completo.

Limitaciones:

• Actualmente, el App Prototyping agent solo soporta aplicaciones web con Next.js. 
• Las funciones de IA generativa están sujetas a la Política de Uso Prohibido de IA Generativa y los Términos de Servicio de Gemini API. 
• Para evitar que los datos se usen en entrenamiento de modelos, se puede desactivar la finalización de código o evitar el uso del App Prototyping agent.
• La interfaz está principalmente en inglés, aunque acepta instrucciones en español.

Ejemplo de uso:

Un usuario puede describir: "Quiero una aplicación web para gestionar tareas con autenticación de usuarios y un diseño minimalista". Firebase Studio genera un prototipo funcional en minutos, con código, interfaz y API configurada. Luego, el usuario puede ajustar el diseño con Gemini, editar el código manualmente o publicarlo directamente.

Un punto de vista...

El creciente número de plataformas que usan IA debería ponernos a pensar: ¿En un futuro todo será automatizado y, por ende, no se necesitará de intervención humana?

Solo el tiempo lo dirá.

Nota curiosa: ¡Este es el post número 333 del blog!

Enlaces:

https://firebase.studio/
https://code.visualstudio.com/
https://atom-editor.cc/

GCP: Calculando el IMC con BigQuery

 

En esta ocasión veremos cómo crear una función y procedimiento almacenado para el cálculo del IMC (Índice de Masa Corporal), necesitaremos lo siguiente:

1. La fórmula para el cálculo del IMC.
2. Crear una función para calcularlo.
3. Crear un procedimiento almacenado (stored procedure) para usar la función.
4. Crear un bloque de código en BigQuery para invocar el procedimiento. 

Tenemos la fórmula:

-- Obtener IMC
IMC = p/(t*t)

Donde:
p= peso
t= talla o estatura
imc = el índice de masa corporal

Creando función para calcular el IMC:

CREATE OR REPLACE FUNCTION `myproject.dataset.imcCalculo`(peso NUMERIC, talla NUMERIC)
RETURNS NUMERIC AS(
  (peso/(talla*talla))
);

Básicamente es una operación sencilla que solo incluye una multiplicación de la talla y la división del peso.

Creando procedimiento almacenado para invocar la función:

CREATE OR REPLACE PROCEDURE `myproject.dataset.getIMC`(peso NUMERIC, talla NUMERIC, OUT msg STRING)
BEGIN 
  DECLARE imc NUMERIC DEFAULT 0.0;
  
  set msg = 'Iniciamos calculo. ';
  SET imc = (SELECT `myproject.dataset.imcCalculo`(peso, talla));
  set msg = concat(msg, 'El IMC es: ', imc, '. Resultado: ');
  set msg = concat(msg, (  
    CASE imc
    WHEN imc<=16.0 OR imc<=16.99 THEN 'Delgadez moderada.'
    WHEN imc<=17.0 OR imc<=18.49 THEN 'Delgadez aceptable.'
    WHEN imc<=18.50 OR imc<=24.99 THEN 'Peso normal.'
    WHEN imc<=25.0 OR imc<=29.99 THEN 'Sobrepeso.'
    WHEN imc<=30.0 OR imc<=34.99 THEN 'Obeso tipo I.'
    WHEN imc<=35.0 OR imc<=40.0 THEN 'Obeso tipo II.'
    ELSE 'No existe clasificacion'
    END)
  );
  
  
  SELECT msg;
  

END;

En el procedimiento almacenado incluimos un mensaje de salida (OUT msg STRING) el cual podrá ser consultado al finalizar el llamado. Este contendrá el cálculo del IMC y el diagnóstico final (peso normal, sobrepeso, etc.).

Creando bloque de BigQuery para invocar procedimiento almacenado:

-- Obtener IMC
BEGIN  
DECLARE peso NUMERIC DEFAULT 56.0;
DECLARE talla NUMERIC DEFAULT 1.65;
DECLARE msg STRING DEFAULT 'Inicio';

CALL `myproject.dataset.getIMC`(peso, talla, msg);
SELECT msg;

END;

Usar un bloque nos ayuda a disminuir una cantidad "grosera" de sentencias.

El resultado de la operación nos dará como resultado: 20.5693. La salida será:

Iniciamos calculo. El IMC es:  20.569329. Resultado: Peso normal.

Crear funciones y procedimientos almacenados es algo muy útil y que nos ahorrará trabajo.

Enlaces:

https://cloud.google.com/bigquery/docs/reference/standard-sql/conditional_expressions
https://codemonkeyjunior.blogspot.com/2024/08/gcp-cargar-y-exportar-datos-en-bigquery.html

https://lineadecodigo.com/java/calcular-el-indice-de-masa-corporal-con-java/
https://codemonkeyjunior.blogspot.com/2013/05/programando-en-ceylon-no1_13.html

GCP: Cargar y exportar datos en BigQuery

GCP BigQuery nos permite tanto cargar como exportar datos. Los formatos de los archivos pueden ser TXT o CSV generalmente.

Si queremos exportar datos de una tabla a un archivo CSV podríamos hacer los siguiente.

Abrimos la consola de GCP y en el editor de consultas colocamos:

EXPORT DATA
  OPTIONS (
    uri = 'gs://bucket/folder/pesos*.csv',
    format = 'CSV',
    overwrite = true,
    header = true,
    field_delimiter = ';')
AS (
  SELECT fecha, valor
  FROM mydataset.pesos
  ORDER BY fecha
);

Como se puede ver:

1. Colocamos la ubicación de nuestro Bucket.
2. Seteamos el formato del archivo, en este caso será un CSV.
3. El archivo será sobreescrito.
4. El delimitardor será un punto y coma (;).

Una vez que el comando es ejecutado desde el editor de consultas GCP, debemos uicarnos en el directorio y descargar el archivo CSV generado.

Si queremos complicarnos la vida, podríamos crear un programa en Java que haga exactamente los mismo.

ExtractTableToCsv.java

import com.google.cloud.RetryOption;
import com.google.cloud.bigquery.BigQuery;
import com.google.cloud.bigquery.BigQueryException;
import com.google.cloud.bigquery.BigQueryOptions;
import com.google.cloud.bigquery.Job;
import com.google.cloud.bigquery.Table;
import com.google.cloud.bigquery.TableId;
import org.threeten.bp.Duration;

public class ExtractTableToCsv {

  public static void runExtractTableToCsv() {
    // TODO(developer): Replace these variables before running the sample.
    String projectId = "bigquery-public-data";
    String datasetName = "samples";
    String tableName = "shakespeare";
    String bucketName = "my-bucket";
    String destinationUri = "gs://" + bucketName + "/path/to/file";
    // For more information on export formats available see:
    // https://cloud.google.com/bigquery/docs/exporting-data#export_formats_and_compression_types
    // For more information on Job see:
    // https://googleapis.dev/java/google-cloud-clients/latest/index.html?com/google/cloud/bigquery/package-summary.html

    String dataFormat = "CSV";
    extractTableToCsv(projectId, datasetName, tableName, destinationUri, dataFormat);
  }

  // Exports datasetName:tableName to destinationUri as raw CSV
  public static void extractTableToCsv(
      String projectId,
      String datasetName,
      String tableName,
      String destinationUri,
      String dataFormat) {
    try {
      // Initialize client that will be used to send requests. This client only needs to be created
      // once, and can be reused for multiple requests.
      BigQuery bigquery = BigQueryOptions.getDefaultInstance().getService();

      TableId tableId = TableId.of(projectId, datasetName, tableName);
      Table table = bigquery.getTable(tableId);

      Job job = table.extract(dataFormat, destinationUri);

      // Blocks until this job completes its execution, either failing or succeeding.
      Job completedJob =
          job.waitFor(
              RetryOption.initialRetryDelay(Duration.ofSeconds(1)),
              RetryOption.totalTimeout(Duration.ofMinutes(3)));
      if (completedJob == null) {
        System.out.println("Job not executed since it no longer exists.");
        return;
      } else if (completedJob.getStatus().getError() != null) {
        System.out.println(
            "BigQuery was unable to extract due to an error: \n" + job.getStatus().getError());
        return;
      }
      System.out.println(
          "Table export successful. Check in GCS bucket for the " + dataFormat + " file.");
    } catch (BigQueryException | InterruptedException e) {
      System.out.println("Table extraction job was interrupted. \n" + e.toString());
    }
  }
}

Ahora, ¿si queremos cargar un archivo a una determinada tabla?

Procedemos a escribir la siguiente instrucción en el editor de consultas de GCP:

LOAD DATA INTO mydataset.pesos FROM FILES(
  format = 'CSV',
  uri = ['gs://bucket/folder/123.csv','gs://bucket/folder/456.csv']
);

Donde:

1. Definimos el formato de los archivos a cargar, en este caso son CSV.
2. Colocamos la ubicación de los archivos de datos a cargar en la tabla (pesos).

Nota: El archivo CSV debe contener campos que concuerden con los de la tabla. En caso contrario, habrá errores a la hora de la carga.

Si queremos complicarnos la vida, podríamos crear un programa en Java que haga exactamente los mismo.

LoadCsvFromGcs.java

import com.google.cloud.bigquery.BigQuery;
import com.google.cloud.bigquery.BigQueryException;
import com.google.cloud.bigquery.BigQueryOptions;
import com.google.cloud.bigquery.CsvOptions;
import com.google.cloud.bigquery.Field;
import com.google.cloud.bigquery.Job;
import com.google.cloud.bigquery.JobInfo;
import com.google.cloud.bigquery.LoadJobConfiguration;
import com.google.cloud.bigquery.Schema;
import com.google.cloud.bigquery.StandardSQLTypeName;
import com.google.cloud.bigquery.TableId;

// Sample to load CSV data from Cloud Storage into a new BigQuery table
public class LoadCsvFromGcs {

  public static void runLoadCsvFromGcs() throws Exception {
    // TODO(developer): Replace these variables before running the sample.
    String datasetName = "MY_DATASET_NAME";
    String tableName = "MY_TABLE_NAME";
    String sourceUri = "gs://cloud-samples-data/bigquery/us-states/us-states.csv";
    Schema schema =
        Schema.of(
            Field.of("name", StandardSQLTypeName.STRING),
            Field.of("post_abbr", StandardSQLTypeName.STRING));
    loadCsvFromGcs(datasetName, tableName, sourceUri, schema);
  }

  public static void loadCsvFromGcs(
      String datasetName, String tableName, String sourceUri, Schema schema) {
    try {
      // Initialize client that will be used to send requests. This client only needs to be created
      // once, and can be reused for multiple requests.
      BigQuery bigquery = BigQueryOptions.getDefaultInstance().getService();

      // Skip header row in the file.
      CsvOptions csvOptions = CsvOptions.newBuilder().setSkipLeadingRows(1).build();

      TableId tableId = TableId.of(datasetName, tableName);
      LoadJobConfiguration loadConfig =
          LoadJobConfiguration.newBuilder(tableId, sourceUri, csvOptions).setSchema(schema).build();

      // Load data from a GCS CSV file into the table
      Job job = bigquery.create(JobInfo.of(loadConfig));
      // Blocks until this load table job completes its execution, either failing or succeeding.
      job = job.waitFor();
      if (job.isDone()) {
        System.out.println("CSV from GCS successfully added during load append job");
      } else {
        System.out.println(
            "BigQuery was unable to load into the table due to an error:"
                + job.getStatus().getError());
      }
    } catch (BigQueryException | InterruptedException e) {
      System.out.println("Column not added during load append \n" + e.toString());
    }
  }
}

Nota: El código se tomó de la página oficial de GCP. Tu lo puedes editar a tu conveniencia.

Hemos visto como cargar y exportar datos a tablas en BigQuery.

Enlaces:

https://cloud.google.com/bigquery/docs/exporting-data
https://cloud.google.com/bigquery/docs/loading-data-cloud-storage-csv

El mercado de la nube: Cloud Computing

 

La computación en la nube (cloud computing) es un modelo de entrega de servicios de tecnología de la información (TI) que permite acceder a recursos informáticos, como servidores, almacenamiento, bases de datos, redes, software y otros servicios, a través de internet. 

Estos recursos son gestionados por proveedores de servicios en la nube y se ofrecen a los usuarios bajo demanda, generalmente con un modelo de pago por uso.

Características de la Computación en la Nube:

1. Acceso bajo demanda: Los usuarios pueden acceder a los recursos de computación y almacenamiento cuando los necesitan, sin necesidad de interacción humana con el proveedor del servicio.

2. Acceso remoto: Los servicios en la nube están disponibles a través de internet, lo que permite acceder a ellos desde cualquier lugar y en cualquier momento.

3. Escalabilidad: Los recursos en la nube pueden escalarse rápidamente hacia arriba o hacia abajo según las necesidades del usuario, proporcionando flexibilidad para adaptarse a las demandas cambiantes.

4. Pago por uso: Los usuarios pagan solo por los recursos que utilizan, lo que puede ser más económico que mantener una infraestructura propia.

5. Mantenimiento y administración: El proveedor del servicio en la nube se encarga del mantenimiento, actualizaciones y administración de los recursos, permitiendo a los usuarios centrarse en sus actividades principales.

Modelos de Servicio en la Computación en la Nube:

1. Infraestructura como Servicio (IaaS): Proporciona recursos de infraestructura básicos, como máquinas virtuales, almacenamiento y redes. Ejemplos: Amazon Web Services (AWS), Microsoft Azure, Google Cloud Platform (GCP).

2. Plataforma como Servicio (PaaS): Proporciona una plataforma que permite a los desarrolladores construir, desplegar y gestionar aplicaciones sin preocuparse por la infraestructura subyacente. Ejemplos: Google App Engine, Microsoft Azure App Services, Heroku.

3. Software como Servicio (SaaS): Proporciona aplicaciones completas que se ejecutan en la nube y están disponibles para los usuarios a través de internet. Ejemplos: Google Workspace, Microsoft Office 365, Salesforce.

Modelos de Implementación de la Computación en la Nube:

1. Nube pública: Los servicios son ofrecidos al público en general por un proveedor de servicios en la nube. Los recursos se comparten entre múltiples usuarios o clientes. Ejemplos: AWS, Azure, GCP.

2. Nube privada: Los servicios se utilizan exclusivamente por una sola organización. La infraestructura puede ser gestionada internamente o por un tercero, y puede estar ubicada dentro de las instalaciones de la organización o externamente.

3. Nube híbrida: Combina nubes públicas y privadas, permitiendo que los datos y aplicaciones se compartan entre ellas. Este modelo proporciona más flexibilidad y optimiza la infraestructura y la seguridad.

4. Nube comunitaria: La infraestructura es compartida por varias organizaciones con intereses comunes, como requisitos de seguridad o cumplimiento.

Ventajas de la Computación en la Nube:

• Reducción de costos: No es necesario invertir en infraestructura física y se paga solo por los recursos utilizados.
• Flexibilidad y escalabilidad: Permite ajustar rápidamente los recursos según las necesidades del negocio.
• Acceso global: Permite acceder a los servicios desde cualquier lugar con conexión a internet.
• Innovación: Facilita la implementación rápida de nuevas tecnologías y servicios.
• Mantenimiento y seguridad: El proveedor de servicios en la nube se encarga de la seguridad y el mantenimiento, liberando a las organizaciones de estas tareas.

Desafíos de la Computación en la Nube:

• Seguridad y privacidad: La transferencia y almacenamiento de datos en la nube puede plantear preocupaciones de seguridad.
• Dependencia del proveedor: Las organizaciones dependen de la disponibilidad y fiabilidad del proveedor de servicios en la nube.
• Cumplimiento normativo: Las organizaciones deben asegurarse de que los servicios en la nube cumplan con las regulaciones y normativas aplicables.

La computación en la nube ofrece una manera eficiente y flexible de acceder a recursos informáticos y gestionar datos, permitiendo a las organizaciones centrarse en sus competencias principales mientras aprovechan la infraestructura gestionada por proveedores especializados.

Algunos de los servicios más populares en cuanto a Cloud Computing son los siguientes:

Google Cloud

https://cloud.google.com/

Microsoft Azure

https://azure.microsoft.com/es-mx/free

Amazon Web Services

https://aws.amazon.com/es/free

Alibaba Cloud

https://us.alibabacloud.com/

Oracle Cloud

https://www.oracle.com/mx/cloud/

IBM Cloud

https://cloud.ibm.com/

VMWare Cloud

https://vmc.vmware.com/

Cloud Sigma

https://www.cloudsigma.com/

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