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 une plate-forme Open Source sous licence, certifiée Java SE TCK et testée 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.

Si vous utilisez Maven, ajoutez les lignes suivantes à votre fichier pom.xml. Pour en savoir plus sur les BOM, consultez la page The Google Cloud Platform Libraries BOM (BOM des bibliothèques 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 vous utilisez Gradle, ajoutez les éléments suivants à vos dépendances :

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

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

Si vous utilisez sbt, ajoutez les éléments suivants à vos dépendances :

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

Si vous utilisez Visual Studio Code ou IntelliJ, vous pouvez ajouter des bibliothèques clientes à votre projet à l'aide des plug-ins IDE suivants :

• Cloud Code pour VS Code
• Cloud Code pour IntelliJ

Les plug-ins offrent des fonctionnalités supplémentaires, telles que la gestion des clés pour les comptes de service. Reportez-vous à la documentation de chaque plug-in pour plus de détails.

Remarque : Les bibliothèques clientes Java de Google Cloud ne sont actuellement pas compatibles avec Android.

Configurer l'authentification

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

Si vous utilisez un shell local, créez des identifiants d'authentification locaux pour votre compte utilisateur :

gcloud auth application-default login

Vous n'avez pas besoin de le faire si vous utilisez Cloud Shell.

Si une erreur d'authentification est renvoyée et que vous utilisez un fournisseur d'identité (IdP) externe, vérifiez que vous vous êtes connecté à la gcloud CLI avec votre identité fédérée.

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

Étapes suivantes

(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.