Configura un ambiente di sviluppo Java

Questo tutorial mostra come preparare la macchina locale per lo sviluppo con Java, incluso lo sviluppo di app Java che vengono eseguite su Google Cloud. Segui questi passaggi per installare Java e gli strumenti pertinenti.

Suggerimento: se vuoi iniziare rapidamente, Cloud Shell Editor fornisce il supporto IDE per l'intero ciclo di sviluppo delle applicazioni Google Kubernetes Engine e Cloud Run. Cloud Shell Editor è basato su Code - OSS e include gli strumenti Google Cloud CLI e Cloud Code preinstallati.

Obiettivi

• Installare un JDK (Java Development Kit).
• Installare uno strumento di automazione della build.
• Installare gcloud CLI.
• (Facoltativo) Installare un IDE o un editor.
• (Facoltativo) Installare il plug-in IDE Google Cloud .
• Installare le librerie client di Cloud per Java.
• Configurare l'autenticazione.

Installare un JDK (Java Development Kit)

Puoi scegliere qualsiasi distribuzione Java di tua scelta assicurandoti che siano impostate le seguenti variabili di ambiente:

• JAVA_HOME: punta alla base dell'installazione di JDK.
• PATH: include $JAVA_HOME/bin.

Eclipse Temurin è la distribuzione OpenJDK (Java Development Kit) consigliata per l'utilizzo con Google Cloud. Temurin è con licenza open source, certificato Java SE TCK e testato per garantire prestazioni e sicurezza di qualità di produzione.

(Consigliato) Installare Temurin

Le istruzioni di installazione di Temurin variano in base al sistema operativo.

• I file binari sono disponibili per il download.
• Per i container Docker, utilizza l'immagine ufficiale 'eclipse-temurin'.

Se utilizzi le immagini di avvio di Compute Engine, puoi utilizzare i seguenti script di installazione.

CentOS/RHEL/Rocky

1. Determina la versione principale di 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 il file del repository di origine 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. Aggiorna gli elenchi di pacchetti:

   sudo yum update -y

4. Installa Temurin:

   sudo yum install -y temurin-17-jdk

5. Verifica l'installazione:

   java -version

Debian/Ubuntu

1. Installa la chiave GPG del repository pubblico. Se utilizzi Ubuntu 16.4, passa la chiave tramite gpg --dearmor prima di salvarla nel file. (ad es. 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 il nome della distribuzione Linux e crea il file dell'elenco di origine, /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. Aggiorna gli elenchi di pacchetti:

   sudo apt update -y

4. Installa Temurin:

   sudo apt install -y temurin-17-jdk

5. Verifica l'installazione:

   java -version

SLES

1. Determina la versione principale di 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. Installa la chiave GPG del repository pubblico:

   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 versione di SLES e registra il repository Adoptium:

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

4. Aggiorna gli elenchi di pacchetti:

   sudo zypper update -y

5. Installa Temurin:

   sudo zypper install -y temurin-17-jdk

6. Verifica l'installazione:

   java -version

Windows

Per installare Temurin, esegui PowerShell versione 3.0 o successive come un amministratore con i seguenti comandi.

1. Scarica Temurin. Il comando Invoke-WebRequest nelle istruzioni riportate di seguito richiede PowerShell 3.0 o versioni successive.

   $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. Imposta le variabili JAVA_HOME e 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 l'installazione:

   java -version

Installare uno strumento di automazione della build

Apache Maven, Gradle, e SBT sono opzioni di gestione dei pacchetti che possono aiutarti a creare le dipendenze delle app Java in modo rapido e coerente su tutte le piattaforme.

Installare gcloud CLI

Il gcloud CLI è un insieme di strumenti per Google Cloud. Include gcloud e bq, che puoi utilizzare per accedere a Compute Engine, Cloud Storage, BigQuery e altri prodotti e servizi dalla riga di comando. Puoi eseguire questi strumenti in modo interattivo o nei tuoi script automatizzati.

(Facoltativo) Installare un IDE o un editor

Gli editor più diffusi (senza un ordine particolare) utilizzati per sviluppare app Java includono, a titolo esemplificativo:

• Visual Studio Code
• IntelliJ IDEA e/o Webstorm di JetBrains
• Eclipse di Eclipse Foundation
• Atom di GitHub

Questi editor (a volte con l'aiuto di plug-in) ti offrono tutto, dall'evidenziazione della sintassi, all'intellisense e al completamento del codice, fino alle funzionalità di debug completamente integrate.

(Facoltativo) Installare un plug-in IDE

Per accedere a funzioni utili all'interno dell'editor, consulta i seguenti plug-in:

• Cloud Code for IntelliJ
• Cloud Code for VS Code

Installare le librerie client di Cloud per Java

Utilizza le librerie client di Cloud per Java per l'integrazione con Google Cloud servizi come Datastore e Cloud Storage. Puoi installare il pacchetto per una singola API, ad esempio BigQuery, come mostrato nell'esempio seguente.

Se utilizzi Maven, aggiungi quanto segue al file pom.xml. Per saperne di più sui BOM, consulta il BOM delle librerie di Google Cloud.

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

Se utilizzi Gradle, aggiungi quanto segue alle dipendenze:

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

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

Se utilizzi sbt, aggiungi quanto segue alle dipendenze:

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

Se utilizzi Visual Studio Code o IntelliJ, puoi aggiungere librerie client al tuo progetto utilizzando i seguenti plug-in IDE:

• Cloud Code for VS Code
• Cloud Code for IntelliJ

I plug-in forniscono funzionalità aggiuntive, come la gestione delle chiavi per i service account. Per informazioni dettagliate, consulta la documentazione di ogni plug-in.

Nota: le librerie client Java di Cloud al momento non supportano Android.

Configurare l'autenticazione

Per eseguire la libreria client, devi prima configurare l'autenticazione.

Crea le credenziali di autenticazione locali per il tuo account utente:

gcloud auth application-default login

Se viene restituito un errore di autenticazione e utilizzi un provider di identità (IdP) esterno, verifica di aver acceduto a gcloud CLI con la tua identità federata.

Per saperne di più, vedi Autenticarsi per l'utilizzo delle librerie client.

Utilizzare la libreria client

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

Configurare gli endpoint per la libreria client

Se utilizzi API che supportano gli endpoint regionali, utilizza gli endpoint per configurare il server a cui inviare le richieste. Ad esempio, con l'API Google.Cloud.Dataproc.V1, puoi configurare un endpoint client. Scopri di più sugli endpoint regionali per Dataproc qui. Assicurati di sostituire MY-PROJECT con il nome del progetto e us-central1 con la regione appropriata per la tua configurazione nell'esempio seguente:

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

Passaggi successivi

(Facoltativo) Utilizzare il plug-in Maven o Gradle per App Engine

Se sviluppi nell'ambiente standard o flessibile di App Engine, puoi utilizzare i plug-in per gli strumenti di sviluppo Apache Maven e Gradle che forniscono funzioni pratiche per sviluppare, testare ed eseguire il deployment delle tue app direttamente.

Per gli ambienti standard di App Engine

Utilizza il plug-in Maven App Engine o plug-in Gradle per gli ambienti standard di App Engine.

Per gli ambienti flessibili di App Engine

Utilizza il plug-in Maven App Engine o il plug-in Gradle per gli ambienti flessibili di App Engine.

Altre risorse

• Sfoglia la documentazione dei Google Cloud prodotti.
• Clona il repository di esempi Java da GitHub.