Configurer un environnement de développement Java

Ce tutoriel explique comment préparer votre ordinateur local pour le développement Java, y compris le développement d'applications Java s'exécutant surGoogle Cloud. Suivez-le pour installer Java et les outils pertinents.

Conseil : Si vous souhaitez démarrer rapidement, l'éditeur Cloud Shell fournit une compatibilité IDE pour le cycle de développement complet des applications Google Kubernetes Engine et Cloud Run. L'éditeur Cloud Shell est basé sur Code - OSS et est préinstallé avec les outils Google Cloud CLI et Cloud Code.

Objectifs

• Installer un JDK (kit de développement Java)
• Installer un outil de compilation automatique
• Installez gcloud CLI.
• (Facultatif) Installer un IDE ou un éditeur
• (Facultatif) Installez le plug-in IDE Google Cloud .
• Installez les bibliothèques clientes Cloud pour Java.
• Configurez l'authentification.

Installer un JDK (kit de développement Java)

Vous pouvez choisir la distribution Java de votre choix en vous assurant que les variables d'environnement suivantes sont définies :

• JAVA_HOME : pointe vers la base de l'installation du JDK.
• PATH : inclut $JAVA_HOME/bin.

Eclipse Temurin est la distribution OpenJDK (kit de développement Java) recommandée pour une utilisation avecGoogle Cloud. Temurin est Open Source, certifié Java SE TCK et testé pour garantir des performances et une sécurité de qualité en production.

(Recommandé) Installer Temurin

Les instructions d'installation de Temurin varient en fonction du système d'exploitation.

• Les binaires sont disponibles en téléchargement.
• Pour les conteneurs Docker, utilisez l'image officielle "eclipse-temurin".

Si vous utilisez des images de démarrage Compute Engine, vous pouvez utiliser les scripts d'installation suivants.

CentOS/RHEL/Rocky

1. Identifiez la version majeure 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. Créez le fichier de dépôt source 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. Mettez à jour les listes de packages :

   sudo yum update -y

4. Installez Temurin :

   sudo yum install -y temurin-17-jdk

5. Vérifiez l'installation :

   java -version

Debian/Ubuntu

1. Installez la clé GPG du dépôt public. Si vous utilisez Ubuntu 16.4, transmettez la clé via gpg --dearmor avant de l'enregistrer dans un fichier. (ex. : 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. Identifiez le nom de la distribution Linux, puis créez le fichier de liste source /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. Mettez à jour les listes de packages :

   sudo apt update -y

4. Installez Temurin :

   sudo apt install -y temurin-17-jdk

5. Vérifiez l'installation :

   java -version

SLES

1. Déterminez la version majeure 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. Installez la clé GPG du dépôt public :

   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. Déterminez la version de SLES et enregistrez le dépôt Adoptium :

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

4. Mettez à jour les listes de packages :

   sudo zypper update -y

5. Installez Temurin :

   sudo zypper install -y temurin-17-jdk

6. Vérifiez l'installation :

   java -version

Windows

Pour installer Temurin, exécutez PowerShell version 3.0 ou ultérieure en tant qu'administrateur avec les commandes suivantes.

1. Téléchargez Temurin. La commande Invoke-WebRequest présentée dans les instructions ci-dessous nécessite PowerShell 3.0 ou version ultérieure.

   $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. Définissez les variables JAVA_HOME et 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. Vérifiez l'installation :

   java -version

Installer un outil de compilation automatique

Apache Maven, Gradle et SBT sont des options de gestion de packages permettant de créer rapidement et systématiquement des dépendances d'applications Java sur toutes les plates-formes.

Installer gcloud CLI

La gcloud CLI est un ensemble d'outils pour Google Cloud. Il contient gcloud et bq, qui vous permettent d'accéder à Compute Engine, Cloud Storage, BigQuery et à d'autres produits et services à partir de la ligne de commande. Vous pouvez exécuter ces outils de façon interactive ou dans des scripts automatisés.

(Facultatif) Installer un IDE ou un éditeur

Voici une liste non exhaustive d'éditeurs courants permettant de développer des applications Java (sans ordre particulier) :

• Visual Studio Code
• IntelliJ IDEA et/ou Webstorm de JetBrains
• Eclipse de la fondation Eclipse
• Atom de GitHub

Ces éditeurs, parfois accompagnés de plug-ins, contiennent de nombreuses fonctionnalités, telles que la coloration syntaxique, IntelliSense, le complément du code et les fonctions de débogage entièrement intégrées.

(Facultatif) Installer un plug-in IDE

Pour accéder à des fonctions utiles de votre éditeur, découvrez les plug-ins suivants :

• Cloud Code pour IntelliJ
• Cloud Code pour VS Code

Installer les bibliothèques clientes Cloud pour Java

Utilisez les bibliothèques clientes Cloud pour Java afin d'intégrer des services Google Cloud, tels que Datastore et Cloud Storage. Vous pouvez installer le package pour une API individuelle, telle que BigQuery, comme indiqué dans l'exemple suivant.

If you are using Maven, add the following to your pom.xml file. For more information about BOMs, see The Google Cloud Platform Libraries BOM.

<!--  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>

If you are using Gradle, add the following to your dependencies:

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

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

If you are using sbt, add the following to your dependencies:

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

If you're using Visual Studio Code or IntelliJ, you can add client libraries to your project using the following IDE plugins:

• Cloud Code for VS Code
• Cloud Code for IntelliJ

The plugins provide additional functionality, such as key management for service accounts. Refer to each plugin's documentation for details.

Note: Cloud Java client libraries do not currently support Android.

Configurer l'authentification

Pour exécuter la bibliothèque cliente, vous devez d'abord configurer l'authentification.

If you're using a local shell, then create local authentication credentials for your user account:

gcloud auth application-default login

You don't need to do this if you're using Cloud Shell.

If an authentication error is returned, and you are using an external identity provider (IdP), confirm that you have signed in to the gcloud CLI with your federated identity.

Pour en savoir plus, consultez la section S'authentifier à l'aide des bibliothèques clientes.

Utiliser la bibliothèque 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());
  }
}

Configurer les points de terminaison pour la bibliothèque cliente

Si vous utilisez des API compatibles avec les points de terminaison régionaux, utilisez ces points de terminaison pour configurer le serveur auquel envoyer les requêtes. Par exemple, avec l'API Google.Cloud.Dataproc.V1, vous pouvez configurer un point de terminaison client. Pour en savoir plus sur les points de terminaison régionaux pour Dataproc, cliquez ici. Veillez à remplacer MY-PROJECT par le nom de votre projet et us-central1 par la région appropriée à votre configuration dans l'exemple suivant :

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();
 }

Étape suivante

(Facultatif) Utiliser le plug-in Maven ou Gradle pour App Engine

Si vous exploitez l'environnement App Engine standard ou flexible, vous pouvez utiliser des plug-ins pour les outils de compilation Apache Maven et Gradle, qui fournissent des fonctions pratiques pour développer, tester et déployer vos applications directement.

Pour les environnements App Engine standards

Ajoutez le plug-in Maven App Engine ou Gradle pour les environnements App Engine standards.

Pour les environnements App Engine flexibles

Ajoutez le plug-in Maven App Engine ou Gradle pour les environnements App Engine flexibles.

Autres ressources

• Parcourez la documentation sur les produits Google Cloud .
• Clonez le dépôt de fichiers d'exemple Java à partir de GitHub.