Configura un entorno de desarrollo de Java

En este instructivo se muestra cómo preparar tu máquina local para el desarrollo de Java, incluido el desarrollo de aplicaciones de Java que se ejecutan en Google Cloud. Sigue estos pasos para instalar Java y las herramientas pertinentes.

Sugerencia: Si quieres comenzar con rapidez, el editor de Cloud Shell proporciona compatibilidad con IDE durante todo el ciclo de desarrollo de las aplicaciones de Google Kubernetes Engine y Cloud Run. El editor de Cloud Shell se basa en Code - OSS y viene con las herramientas de Google Cloud CLI y Cloud Code preinstaladas.

Objetivos

• Instalar un JDK (Java Development Kit)
• Instalar una herramienta de compilación automática
• Instalar gcloud CLI
• Instalar un IDE o editor (opcional)
• Instalar IDE Google Cloud plugin (opcional)
• Instalar las bibliotecas cliente de Cloud para Java
• Configurar la autenticación

Instala un JDK (Java Development Kit)

Puedes elegir cualquier distribución de Java que desees. Para ello, asegúrate de que se establezcan las siguientes variables de entorno:

• JAVA_HOME: Debe apuntar a la base de la instalación del JDK.
• PATH: Incluye $JAVA_HOME/bin.

Eclipse Temurin es la distribución recomendada de OpenJDK (Java Development Kit) para usar con Google Cloud. Temurin tiene licencia de código abierto, está certificado por Java SE TCK y se probó para garantizar el rendimiento y la seguridad de calidad de producción.

(Recomendado) Instala Temurin

Las instrucciones de instalación de Temurin varían según el sistema operativo.

• Los objetos binarios están disponibles para su descarga.
• Para los contenedores de Docker, usa la imagen oficial “eclipse-temurin”.

Si usas imágenes de arranque de Compute Engine, puedes usar las siguientes secuencias de comandos de instalación.

CentOS/RHEL/Rocky

1. Determina la versión principal de CentOS/RHEL/Rocky Linux:

   eval "$(grep VERSION_ID /etc/os-release)"
   eval "$(grep ^ID= /etc/os-release)"
   OLD_IFS=$IFS
   IFS='.'
   read -ra split_version <<< "$VERSION_ID"
   IFS=$OLD_IFS
   MAJOR_VERSION=$split_version

2. Crea el archivo de repositorio de origen de Adoptium, `/etc/yum.repos.d/adoptium.repo`:

   sudo tee /etc/yum.repos.d/adoptium.repo << EOM
   [Adoptium]
   name=Adoptium
   baseurl=https://packages.adoptium.net/artifactory/rpm/$ID/$MAJOR_VERSION/\$basearch
   enabled=1
   gpgcheck=1
   gpgkey=https://packages.adoptium.net/artifactory/api/gpg/key/public
   EOM

3. Actualiza las listas de paquetes:

   sudo yum update -y

4. Instala Temurin:

   sudo yum install -y temurin-17-jdk

5. Verifica la instalación:

   java -version

Debian/Ubuntu

1. Instala la clave GPG pública del repositorio. Si usas Ubuntu 16.4, pasa la clave a través de gpg --dearmor antes de guardarla en el archivo. (p. ej., sudo wget ... | gpg --dearmor | sudo tee ...)

   sudo mkdir -p /etc/apt/keyrings
   sudo wget -O - https://packages.adoptium.net/artifactory/api/gpg/key/public |
     sudo tee /etc/apt/keyrings/adoptium.asc

2. Determina el nombre de la distribución de Linux y crea el archivo de lista de origen, /etc/apt/sources.list.d/adoptium.list:

   eval "$(grep VERSION_CODENAME /etc/os-release)"
   sudo tee /etc/apt/sources.list.d/adoptium.list << EOM
   deb [signed-by=/etc/apt/keyrings/adoptium.asc] https://packages.adoptium.net/artifactory/deb $VERSION_CODENAME main
   EOM

3. Actualiza las listas de paquetes:

   sudo apt update -y

4. Instala Temurin:

   sudo apt install -y temurin-17-jdk

5. Verifica la instalación:

   java -version

SLES

1. Determina la versión principal de SLES:

   eval "$(grep VERSION_ID /etc/os-release)"
   OLD_IFS=$IFS
   IFS='.'
   read -ra split_version <<< "$VERSION_ID"
   IFS=$OLD_IFS
   MAJOR_VERSION=$split_version

2. Instala la clave GPG pública del repositorio:

   sudo mkdir -p /etc/zypp/keyrings
   sudo wget -O - https://packages.adoptium.net/artifactory/api/gpg/key/public |
     sudo tee /etc/zypp/keyrings/adoptium.asc
   sudo rpm --import /etc/zypp/keyrings/adoptium.asc

3. Determina la versión de SLES y registra el repositorio de Adoptium:

   sudo zypper ar -f "https://packages.adoptium.net/artifactory/rpm/sles/$MAJOR_VERSION/$(uname -m)" adoptium

4. Actualiza las listas de paquetes:

   sudo zypper update -y

5. Instala Temurin:

   sudo zypper install -y temurin-17-jdk

6. Verifica la instalación:

   java -version

Windows

Para instalar Temurin, ejecuta PowerShell versión 3.0 o superior como un administrador con los siguientes comandos.

1. Descarga Temurin. El comando Invoke-WebRequest de las siguientes instrucciones requiere PowerShell 3.0 o una versión posterior.

   $JdkVersion = 17
   $JdkUrl = "https://api.adoptium.net/v3/binary/latest/$JdkVersion/ga/windows/x64/jdk/hotspot/normal/eclipse?project=jdk"
   $JdkExtractionPath = "C:\temurin-$JdkVersion-jdk"
   $JdkDownload = "$JdkExtractionPath.zip"
   [System.Net.ServicePointManager]::SecurityProtocol = [System.Net.SecurityProtocolType]'Tls12'
   Invoke-WebRequest -Uri $JdkUrl -OutFile $JdkDownload
   Expand-Archive $JdkDownload -DestinationPath $JdkExtractionPath -Force

2. Establece las variables JAVA_HOME y Path:

   pushd $JdkExtractionPath
   $JdkPath = (Get-ChildItem).FullName
   popd
   [System.Environment]::SetEnvironmentVariable('JAVA_HOME', $JdkPath, 'Machine')
   
         

3. (Optional) Refresh your session's `$env:Path` value. Otherwise, start a new session:

   $MachinePath = [System.Environment]::GetEnvironmentVariable('Path', 'Machine')
   $UserPath = [System.Environment]::GetEnvironmentVariable('Path', 'User')
   $env:Path = "$MachinePath;$UserPath"

4. Verifica la instalación:

   java -version

Instala una herramienta de compilación automática

Apache Maven, Gradle, y SBT son opciones de administración de paquetes que pueden ayudar a compilar dependencias de aplicaciones de Java de manera rápida y coherente en todas las plataformas.

Instala gcloud CLI

El gcloud CLI es un conjunto de herramientas para Google Cloud. Contiene gcloud y bq, que puedes usar para acceder a Compute Engine, Cloud Storage, BigQuery y otros productos y servicios desde la línea de comandos. Puedes ejecutar estas herramientas de manera interactiva o en tus secuencias de comandos automatizadas.

Instala un IDE o editor (opcional)

Estos son algunos editores conocidos que se usan para desarrollar apps de Java (sin un orden especial):

• Visual Studio Code
• IntelliJ IDEA o Webstorm de JetBrains
• Eclipse de Eclipse Foundation
• Atom de GitHub

Estos editores (con la ayuda de complementos, en algunos casos) te proporcionan todas las herramientas, como la sintaxis destacada, IntelliSense, funciones de autocompletar código y funciones de depuración completamente integradas.

Instala un complemento de IDE (opcional)

Para acceder a funciones útiles dentro de tu editor, revisa los siguientes complementos:

• Cloud Code para IntelliJ
• Cloud Code para VS Code

Instala las bibliotecas cliente de Cloud para Java

Usa las bibliotecas cliente de Cloud para Java para integrar Google Cloud servicios, como Datastore y Cloud Storage. Puedes instalar el paquete para una API individual, como BigQuery, de la manera que se muestra en el siguiente ejemplo.

Si usas Maven, agrega lo siguiente al archivo pom.xml. Para obtener más información sobre las BOM, consulta Las bibliotecas de BOM de Google Cloud Platform.

<!--  Using libraries-bom to manage versions.
See https://github.com/GoogleCloudPlatform/cloud-opensource-java/wiki/The-Google-Cloud-Platform-Libraries-BOM -->
<dependencyManagement>
  <dependencies>
    <dependency>
      <groupId>com.google.cloud</groupId>
      <artifactId>libraries-bom</artifactId>
      <version>26.62.0</version>
      <type>pom</type>
      <scope>import</scope>
    </dependency>
  </dependencies>
</dependencyManagement>

<dependencies>
  <dependency>
    <groupId>com.google.cloud</groupId>
    <artifactId>google-cloud-bigquery</artifactId>
  </dependency>
</dependencies>

Si usas Gradle, agrega lo siguiente a las dependencias:

implementation platform('com.google.cloud:libraries-bom:26.45.0')

implementation 'com.google.cloud:google-cloud-bigquery'

Si usas sbt, agrega lo siguiente a las dependencias:

libraryDependencies += "com.google.cloud" % "google-cloud-bigquery" % "2.42.2"

Si usas Visual Studio Code o IntelliJ, puedes agregar bibliotecas cliente a tu proyecto con los siguientes complementos IDE:

• Cloud Code para VS Code
• Cloud Code para IntelliJ

Los complementos brindan funcionalidades adicionales, como administración de claves para las cuentas de servicio. Consulta la documentación de cada complemento para obtener más detalles.

Nota: En este momento, las bibliotecas cliente de Cloud para Java no son compatibles con Android.

Configura la autenticación

Para ejecutar la biblioteca cliente, debes configurar la autenticación.

Si usas un shell local, crea credenciales de autenticación locales para tu cuenta de usuario:

gcloud auth application-default login

No es necesario que lo hagas si usas Cloud Shell.

Si se muestra un error de autenticación y usas un proveedor de identidad (IdP) externo, confirma que accediste a gcloud CLI con tu identidad federada.

Si deseas obtener más información, consulta Autentícate para usar las bibliotecas cliente.

Usa la biblioteca cliente

// Imports the Google Cloud client library
import com.google.cloud.bigquery.BigQuery;
import com.google.cloud.bigquery.BigQueryOptions;
import com.google.cloud.bigquery.Dataset;
import com.google.cloud.bigquery.DatasetInfo;

public class QuickstartSample {
  public static void main(String... args) throws Exception {
    // Instantiate a client. If you don't specify credentials when constructing a client, the
    // client library will look for credentials in the environment, such as the
    // GOOGLE_APPLICATION_CREDENTIALS environment variable.
    BigQuery bigquery = BigQueryOptions.getDefaultInstance().getService();

    // The name for the new dataset
    String datasetName = "my_new_dataset";

    // Prepares a new dataset
    Dataset dataset = null;
    DatasetInfo datasetInfo = DatasetInfo.newBuilder(datasetName).build();

    // Creates the dataset
    dataset = bigquery.create(datasetInfo);

    System.out.printf("Dataset %s created.%n", dataset.getDatasetId().getDataset());
  }
}

Configura extremos para la biblioteca cliente

Si usas APIs que admiten extremos regionales, usa extremos para configurar a qué servidor enviar solicitudes. Por ejemplo, con la API de Google.Cloud.Dataproc.V1, puedes configurar un extremo de cliente. Puedes leer más sobre los extremos regionales de Dataproc aquí. Asegúrate de reemplazar MY-PROJECT por el nombre de tu proyecto y us-central1 por la región adecuada para tu configuración en el siguiente ejemplo:

ClusterControllerSettings settings =
     ClusterControllerSettings.newBuilder()
        .setEndpoint("us-central1-dataproc.googleapis.com:443")
        .build();
 try (ClusterControllerClient clusterControllerClient = ClusterControllerClient.create(settings)) {
   String projectId = "MY-PROJECT";
   String region = "us-central1";
   Cluster cluster = Cluster.newBuilder().build();
 }

¿Qué sigue?

Usa el complemento de Maven o Gradle para App Engine (opcional)

Si desarrollas en el entorno de App Engine Standard o Flexible, puedes usar complementos para las herramientas de compilación de Apache Maven y Gradle que proporcionan funciones útiles de desarrollo, implementación y prueba de apps directamente.

Para entornos de App Engine Standard

Agrega el Maven App Engine Plugin o el complemento de Gradle para los entornos estándar de App Engine.

Para entornos de App Engine Flexible

Agrega el complemento de Maven App Engine o el complemento de Gradle para los entornos flexibles de App Engine.

Más recursos

• Explora la documentación de Google Cloud productos.
• Clona el repositorio de muestras de Java en GitHub.