Comienza a usar Java

Este instructivo está destinado a aquellos que estén comenzando a compilar aplicaciones en la nube, como ingenieros y desarrolladores web, que quieran aprender conceptos clave del desarrollo de aplicaciones y cómo aprovecharlos en Google Cloud.

Objetivos

• Aprender sobre las herramientas básicas de Google Cloud , como la Google Cloud consola y gcloud.
• Implementar tu app en Cloud Run.
• Almacenar tus datos con Firestore
• Almacenar archivos subidos en Cloud Storage.
• Supervisar tu app con Google Cloud Observability

Costos

En este documento, usarás los siguientes componentes facturables de Google Cloud:

• Cloud Run
• Cloud Storage
• Firestore
• Google Cloud Observability

Las instrucciones de este documento están diseñadas para que el uso de los recursos se mantenga dentro de los límites del nivel Siempre gratuito de Google Cloud's. Para generar una estimación de costos en función del uso previsto, usa la calculadora de precios.

Es posible que los usuarios de Google Cloud nuevos cumplan con los requisitos para acceder a una prueba gratuita.

Cuando completes las tareas que se describen en este documento, podrás borrar los recursos que creaste para evitar que se te siga facturando. Para obtener más información, consulta Realiza una limpieza.

Antes de comenzar

Accede a tu Google Cloud cuenta de. Si eres nuevo en Google Cloud, crea una cuenta para evaluar el rendimiento de nuestros productos en situaciones reales. Los clientes nuevos también obtienen $300 en créditos gratuitos para ejecutar, probar y, además, implementar cargas de trabajo.

In the Google Cloud console, on the project selector page, select or create a Google Cloud project.

Roles required to select or create a project

• Select a project: Selecting a project doesn't require a specific IAM role—you can select any project that you've been granted a role on.
• Create a project: To create a project, you need the Project Creator role (roles/resourcemanager.projectCreator), which contains the resourcemanager.projects.create permission. Learn how to grant roles.

Note: If you don't plan to keep the resources that you create in this procedure, create a project instead of selecting an existing project. After you finish these steps, you can delete the project, removing all resources associated with the project.

Go to project selector

Verify that billing is enabled for your Google Cloud project.

In the Google Cloud console, on the project selector page, select or create a Google Cloud project.

Roles required to select or create a project

• Select a project: Selecting a project doesn't require a specific IAM role—you can select any project that you've been granted a role on.
• Create a project: To create a project, you need the Project Creator role (roles/resourcemanager.projectCreator), which contains the resourcemanager.projects.create permission. Learn how to grant roles.

Note: If you don't plan to keep the resources that you create in this procedure, create a project instead of selecting an existing project. After you finish these steps, you can delete the project, removing all resources associated with the project.

Go to project selector

Verify that billing is enabled for your Google Cloud project.

1. Para crear una base de datos de Firestore en modo nativo, sigue los pasos a continuación:
   1. En la Google Cloud consola, ve a la página Crear base de datos de Firestore.
      

      Ir a Crear base de datos de Firestore

   2. Desde la pantalla Selecciona un modo de Cloud Firestore, haz clic en Seleccionar modo nativo.
   3. Selecciona una ubicación para tu base de datos de Firestore. Esta configuración corresponde a la ubicación Google Cloud de recursos predeterminada para tu Google Cloud proyecto . La configuración de la ubicación se usa en los Google Cloud servicios de tu Google Cloud proyecto de que la requieren; en particular, el bucket predeterminado de Cloud Storage y la aplicación de Cloud Run.
      Advertencia: Una vez que configures la ubicación predeterminada de los recursos del Google Cloud proyecto de, no podrás cambiarla.
   4. Haz clic en Crear base de datos.

2. Habilita las APIs de Cloud Run Admin, Cloud Storage, Cloud Logging y Error Reporting.

   Roles necesarios para habilitar las APIs

   Para habilitar las APIs, necesitas el rol de IAM de administrador de Service Usage (roles/serviceusage.serviceUsageAdmin), que contiene el permiso serviceusage.services.enable. Obtén más información para otorgar roles.

   Habilitar las API

3. Clona el repositorio de muestra y abre la aplicación de muestra en Cloud Shell:
   Ir a Cloud Shell

   Cloud Shell brinda acceso de línea de comandos a los Google Cloud recursos de tu proyecto directamente desde el navegador.

4. En el mensaje para clonar el repositorio, haz clic en Confirmar.

5. En Cloud Shell, configura la herramienta de gcloud para que use tu proyecto nuevo Google Cloud de la siguiente manera:

   # Configure gcloud for your project
   gcloud config set project PROJECT_ID

   Reemplaza PROJECT_ID con el Google Cloud ID del proyecto que creaste con la Google Cloud consola.

   La CLI de Google Cloud es la forma principal en la que interactúas con tus Google Cloud recursos de desde la línea de comandos. En este instructivo, usarás la herramienta gcloud para implementar y supervisar tu aplicación.

Ejecuta tu app

1. Si ya usas Cloud Shell y lo configuraste para usar Java 11, actualiza las alternativas de Java de shell, JAVA_HOME y las variables de entorno PATH para especificar Java 8.
2. Cambia al directorio bookshelf/1-cloud-run y ejecuta la aplicación, con el siguiente comando:

   GOOGLE_CLOUD_PROJECT=PROJECT_ID mvn -Plocal clean jetty:run-exploded
   

   Reemplaza PROJECT_ID por el ID del Google Cloud proyecto que creaste.
3. En Cloud Shell, haz clic en Vista previa en la Web , y selecciona Vista previa en el puerto 8080. Se abrirá una ventana nueva con tu app en ejecución.

Implementa tu app en Cloud Run

Google Cloud ofrece varias opciones para ejecutar tu código. Para este ejemplo, usa Cloud Run a fin de implementar una app escalable en Google Cloud. Cloud Run no requiere que administres servidores ni se escala de forma automática para admitir los aumentos de tráfico.

Sigue las instrucciones en Implementa tu app en Cloud Run.

Cuando la implementación se realiza de forma correcta, se muestra un extremo de la app que se ejecuta en Cloud Run en el siguiente formato:

https://bookshelf-abcdefghij-uc.a.run.app

Tu app ya se puede visualizar en este enlace, que de ahora en más se llamará YOUR_CLOUD_RUN_URL. En tu navegador web, ingresa la URL para ver la app.

Almacenar tus datos con Firestore

No se puede almacenar información en tus instancias de Cloud Run porque se perderá si se reinicia la instancia, además de que no existirá cuando se creen instancias nuevas. En su lugar, usarás una base de datos en la que todas tus instancias puedan leer y escribir.

Google Cloud ofrece varias opciones para almacenar tus datos. En este ejemplo, usarás Firestore para almacenar los datos de cada libro. Firestore es una base de datos de documentos NoSQL, completamente administrada y sin servidores que te permite almacenar y consultar datos. Firestore escala de manera automática para cumplir las necesidades de tu aplicación y escala a cero cuando no la estás usando. Agrega el primer libro.

1. En tu navegador web, ve a YOUR_CLOUD_RUN_URL.

2. Si deseas crear un libro para la app implementada, haz clic en Add book.

   
3. En el campo Title, ingresa Moby Dick.
4. En el campo Author, ingresa Herman Melville.

5. Haz clic en Save. Ya tienes una entrada en la aplicación Bookshelf.

   
6. En la Google Cloud consola, haz clic en Actualizar para actualizar la página de Firestore. Los datos aparecen en Firestore. La aplicación Bookshelf almacena cada libro como un documento de Firestore con un ID único, y todos estos documentos se almacenan en una colección de Firestore. Para los propósitos de este instructivo, la colección se llama “books”.

Firestore almacena los libros mediante la biblioteca cliente de Firestore. Aquí hay un ejemplo de recuperación de un documento de Firestore:

public class FirestoreDao implements BookDao {
  private CollectionReference booksCollection;

  public FirestoreDao() {
    Firestore firestore = FirestoreOptions.getDefaultInstance().getService();
    booksCollection = firestore.collection("books");
  }

  private Book documentToBook(DocumentSnapshot document) {
    Map<String, Object> data = document.getData();
    if (data == null) {
      System.out.println("No data in document " + document.getId());
      return null;
    }

    return new Book.Builder()
        .author((String) data.get(Book.AUTHOR))
        .description((String) data.get(Book.DESCRIPTION))
        .publishedDate((String) data.get(Book.PUBLISHED_DATE))
        .imageUrl((String) data.get(Book.IMAGE_URL))
        .createdBy((String) data.get(Book.CREATED_BY))
        .createdById((String) data.get(Book.CREATED_BY_ID))
        .title((String) data.get(Book.TITLE))
        .id(document.getId())
        .build();
  }

  @Override
  public String createBook(Book book) {
    String id = UUID.randomUUID().toString();
    DocumentReference document = booksCollection.document(id);
    Map<String, Object> data = Maps.newHashMap();

    data.put(Book.AUTHOR, book.getAuthor());
    data.put(Book.DESCRIPTION, book.getDescription());
    data.put(Book.PUBLISHED_DATE, book.getPublishedDate());
    data.put(Book.TITLE, book.getTitle());
    data.put(Book.IMAGE_URL, book.getImageUrl());
    data.put(Book.CREATED_BY, book.getCreatedBy());
    data.put(Book.CREATED_BY_ID, book.getCreatedById());
    try {
      document.set(data).get();
    } catch (InterruptedException | ExecutionException e) {
      e.printStackTrace();
    }

    return id;
  }

  @Override
  public Book readBook(String bookId) {
    try {
      DocumentSnapshot document = booksCollection.document(bookId).get().get();

      return documentToBook(document);
    } catch (InterruptedException | ExecutionException e) {
      e.printStackTrace();
    }
    return null;
  }

  @Override
  public void updateBook(Book book) {
    DocumentReference document = booksCollection.document(book.getId());
    Map<String, Object> data = Maps.newHashMap();

    data.put(Book.AUTHOR, book.getAuthor());
    data.put(Book.DESCRIPTION, book.getDescription());
    data.put(Book.PUBLISHED_DATE, book.getPublishedDate());
    data.put(Book.TITLE, book.getTitle());
    data.put(Book.IMAGE_URL, book.getImageUrl());
    data.put(Book.CREATED_BY, book.getCreatedBy());
    data.put(Book.CREATED_BY_ID, book.getCreatedById());
    try {
      document.set(data).get();
    } catch (InterruptedException | ExecutionException e) {
      e.printStackTrace();
    }
  }

  @Override
  public void deleteBook(String bookId) {
    try {
      booksCollection.document(bookId).delete().get();
    } catch (InterruptedException | ExecutionException e) {
      e.printStackTrace();
    }
  }

  private List<Book> documentsToBooks(List<QueryDocumentSnapshot> documents) {
    List<Book> resultBooks = new ArrayList<>();
    for (QueryDocumentSnapshot snapshot : documents) {
      resultBooks.add(documentToBook(snapshot));
    }
    return resultBooks;
  }

  @Override
  public Result<Book> listBooks(String startTitle) {
    Query booksQuery = booksCollection.orderBy("title").limit(10);
    if (startTitle != null) {
      booksQuery = booksQuery.startAfter(startTitle);
    }
    try {
      QuerySnapshot snapshot = booksQuery.get().get();
      List<Book> results = documentsToBooks(snapshot.getDocuments());
      String newCursor = null;
      if (results.size() > 0) {
        newCursor = results.get(results.size() - 1).getTitle();
      }
      return new Result<>(results, newCursor);
    } catch (InterruptedException | ExecutionException e) {
      e.printStackTrace();
    }
    return new Result<>(Lists.newArrayList(), null);
  }

  @Override
  public Result<Book> listBooksByUser(String userId, String startTitle) {
    Query booksQuery =
        booksCollection.orderBy("title").whereEqualTo(Book.CREATED_BY_ID, userId).limit(10);
    if (startTitle != null) {
      booksQuery = booksQuery.startAfter(startTitle);
    }
    try {
      QuerySnapshot snapshot = booksQuery.get().get();
      List<Book> results = documentsToBooks(snapshot.getDocuments());
      String newCursor = null;
      if (results.size() > 0) {
        newCursor = results.get(results.size() - 1).getTitle();
      }
      return new Result<>(results, newCursor);
    } catch (InterruptedException | ExecutionException e) {
      e.printStackTrace();
    }
    return new Result<>(Lists.newArrayList(), null);
  }
}

Para obtener más información sobre el uso de Firestore, consulta cómo agregar datos a Firestore.

Almacenar archivos subidos en Cloud Storage

Ahora que agregaste un libro, es momento de agregar su imagen de portada. No puedes almacenar archivos en tus instancias. Una base de datos no es la opción correcta para archivos de imagen. En cambio, debes usar Cloud Storage.

Cloud Storage es el almacenamiento de BLOB principal de Google Cloud. Puedes usar Cloud Storage a fin de alojar elementos de aplicaciones que deseas compartir en Google Cloud. Para usar Cloud Storage, debes crear un bucket de Cloud Storage, un contenedor básico en el que se guardan tus datos.

1. En la Google Cloud consola, ve a la página Navegador de Cloud Storage.

   Ir a la página Navegador de Cloud Storage

2. Haz clic en Crear bucket.
3. En el cuadro de diálogo Crear bucket, adjunta el Google Cloud ID del proyecto a la cadena _bucket para ingresar un nombre del bucket, de manera que sea similar a YOUR_PROJECT_ID_bucket. Este nombre está sujeto a los requisitos de nombres de los buckets. En el resto de los campos, se pueden conservar los valores predeterminados.
4. Haz clic en Crear.
5. Una vez que se haya creado el bucket, debe permitirse el acceso público a los objetos para que puedan consultarlos los usuarios. Si quieres permitir el acceso público a tus objetos, consulta el artículo Haz públicos los datos.
6. Haz clic en Edit book y selecciona una imagen para subirla como la portada del libro. Por ejemplo, puedes usar esta imagen de dominio público:
   
7. Haz clic en Save. Se te redireccionará a la página principal, en la que encontrarás una entrada a la app Bookshelf.
   

La app de Bookshelf envía los archivos subidos a Cloud Storage a través de la biblioteca cliente de Cloud Storage.

public class CloudStorageHelper {

  private final Logger logger = Logger.getLogger(CloudStorageHelper.class.getName());
  private static Storage storage = null;

  static {
    storage = StorageOptions.getDefaultInstance().getService();
  }


  /**
   * Uploads a file to Google Cloud Storage to the bucket specified in the BUCKET_NAME environment
   * variable, appending a timestamp to end of the uploaded filename.
   */
  public String uploadFile(FileItemStream fileStream, final String bucketName)
      throws IOException, ServletException {
    checkFileExtension(fileStream.getName());

    System.out.println("FileStream name: " + fileStream.getName() + "\nBucket name: " + bucketName);

    DateTimeFormatter dtf = DateTimeFormat.forPattern("-YYYY-MM-dd-HHmmssSSS");
    DateTime dt = DateTime.now(DateTimeZone.UTC);
    String dtString = dt.toString(dtf);
    final String fileName = fileStream.getName() + dtString;

    // the inputstream is closed by default, so we don't need to close it here
    @SuppressWarnings("deprecation")
    BlobInfo blobInfo =
        storage.create(
            BlobInfo.newBuilder(bucketName, fileName)
                // Modify access list to allow all users with link to read file
                .setAcl(new ArrayList<>(Arrays.asList(Acl.of(User.ofAllUsers(), Role.READER))))
                .build(),
            fileStream.openStream());
    logger.log(
        Level.INFO, "Uploaded file {0} as {1}", new Object[] {fileStream.getName(), fileName});
    // return the public download link
    return blobInfo.getMediaLink();
  }


  /** Checks that the file extension is supported. */
  private void checkFileExtension(String fileName) throws ServletException {
    if (fileName != null && !fileName.isEmpty() && fileName.contains(".")) {
      String[] allowedExt = {".jpg", ".jpeg", ".png", ".gif"};
      for (String ext : allowedExt) {
        if (fileName.endsWith(ext)) {
          return;
        }
      }
      throw new ServletException("file must be an image");
    }
  }
}

Nota: Para cambiar el nombre del bucket, configura la variable bucketName del código anterior con un nombre diferente y vuelve a implementar la app ejecutando gcloud app deploy.

Si quieres obtener más información para usar Cloud Storage, consulta la introducción a Cloud Storage.

Supervisa tu app con Google Cloud Observability

Ya implementaste la app y creaste y modificaste libros. A fin de supervisar estos eventos para los usuarios, usa la administración del rendimiento de las aplicaciones.

Supervisa los registros con Cloud Logging

1. En la Google Cloud, ve al Explorador de registros

   Ir al Explorador de registros

   Puedes supervisar tu app en tiempo real. Si tienes problemas con tu app, este es uno de los primeros lugares que consultar.

   
2. En la lista desplegable Recursos, selecciona Revisión de Cloud Run, bookshelf.

Controla los errores con Error Reporting

1. En la Google Cloud consola, ve a la página Error Reporting.
   Ir a la página Error Reporting
   Error Reporting destaca los errores y las excepciones de la app y te permite configurar alertas basadas en ellos.
2. En el navegador, ve a la URL /errors de la app.
   

   YOUR_CLOUD_RUN_URL/errors

   En esta tarea, se genera una nueva excepción a la prueba y se envía a Google Cloud Observability.

3. En la Google Cloud consola, regresa a la página de Error Reporting y podrás ver el error nuevo en unos instantes. Haz clic en Volver a cargar automáticamente para no tener que actualizar la página de forma manual.

   

Limpia

Para evitar que se apliquen cargos a tu cuenta de Google Cloud por los recursos usados en este instructivo, borra el proyecto que contiene los recursos o conserva el proyecto y borra los recursos individuales.

Borra el proyecto

Precaución: Borrar un proyecto tiene estas consecuencias:

• Se borra todo su contenido. Si usaste un proyecto existente para las tareas de este documento, cuando lo borres, también se borrará cualquier otro trabajo que hayas realizado en el proyecto.
• Se pierden los IDs personalizados de los proyectos. Cuando creaste este proyecto, es posible que hayas creado un ID personalizado del proyecto que desees utilizar en el futuro. Para conservar las URLs que usan el ID del proyecto, como una URL appspot.com, borra los recursos seleccionados dentro del proyecto, en lugar de todo el proyecto.

Si planeas explorar varios instructivos, arquitecturas o guías de inicio rápido, reutilizar proyectos puede ser útil para no exceder los límites de cuota de los proyectos.

1. En la Google Cloud consola, ve a la página Administrar recursos.

   Ir a Administrar recursos

2. En la lista de proyectos, elige el proyecto que tú quieres borrar y haz clic en Borrar.
3. En el diálogo, escribe el ID del proyecto y, luego, haz clic en Cerrar para borrar el proyecto.

¿Qué sigue?

• Implementa una app en Google Kubernetes Engine
• Implementa una aplicación en Compute Engine
• Maneja sesiones con Firestore