Java-Entwicklungsumgebung einrichten

In dieser Anleitung wird beschrieben, wie Sie Ihren lokalen Computer für die Entwicklung mit Java vorbereiten. Dies umfasst die Entwicklung von Java-Anwendungen, die inGoogle Cloudausgeführt werden. Folgen Sie dieser Anleitung, um Java und relevante Tools zu installieren.

Ziele

JDK (Java Development Kit) installieren.
Build-Automatisierungstool installieren.
Installieren Sie die gcloud CLI.
(Optional) IDE oder Editor installieren.
(Optional) IDE Google Cloud Plug-in installieren.
Installieren Sie die Cloud-Clientbibliotheken für Java.
Richten Sie die Authentifizierung ein.

JDK (Java Development Kit) installieren

Sie können eine beliebige Java-Distribution auswählen, sofern die folgenden Umgebungsvariablen festgelegt sind:

JAVA_HOME: Verweist auf das Basisverzeichnis der JDK-Installation.
PATH: Enthält $JAVA_HOME/bin.

Eclipse Temurin ist die empfohlene OpenJDK-Distribution (Java Development Kit) für die Verwendung mitGoogle Cloud. Temurin ist Open-Source-lizenziert, Java SE TCK-zertifiziert und wurde getestet, um eine leistungsstarke und sichere Produktion zu gewährleisten.

(Empfohlen) Temurin installieren

Die Installationsanleitung für Temurin variiert je nach Betriebssystem.

Binärdateien sind zum Herunterladen verfügbar.
Verwenden Sie für Docker-Container das offizielle „eclipse-temurin“-Image.

Wenn Sie Compute Engine-Boot-Images verwenden, können Sie die folgenden Installationsskripts verwenden.

CentOS/RHEL/Rocky

Bestimmen Sie die Hauptversion von 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

Erstellen Sie die Adoptium-Quell-Repository-Datei `/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

Aktualisieren Sie die Paketlisten:
```
sudo yum update -y
```
Installieren Sie Temurin:
```
sudo yum install -y temurin-17-jdk
```
Installation prüfen:
```
java -version
```

Debian/Ubuntu

Installieren Sie den öffentlichen Repo-GPG-Schlüssel. Wenn Sie Ubuntu 16.4 verwenden, geben Sie den Schlüssel über gpg --dearmor ein, bevor Sie ihn in einer Datei speichern. Beispiel: 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
```

Bestimmen Sie den Namen der Linux-Distribution und erstellen Sie die Quelllistendatei /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

Aktualisieren Sie die Paketlisten:
```
sudo apt update -y
```
Installieren Sie Temurin:
```
sudo apt install -y temurin-17-jdk
```
Installation prüfen:
```
java -version
```

SLES

Hauptversion von SLES ermitteln:

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

Installieren Sie den öffentlichen Repository-GPG-Schlüssel:

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

Ermitteln Sie die Version von SLES und registrieren Sie das Adoptium-Repository:

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

Aktualisieren Sie die Paketlisten:
```
sudo zypper update -y
```
Installieren Sie Temurin:
```
sudo zypper install -y temurin-17-jdk
```
Installation prüfen:
```
java -version
```

Windows

Führen Sie zur Installation von Temurin PowerShell Version 3.0 oder höher als Administrator mit den folgenden Befehlen aus.

Laden Sie Temurin herunter. Für den Befehl Invoke-WebRequest in der Anleitung unten ist PowerShell 3.0 oder höher erforderlich.

$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

Legen Sie die Variablen JAVA_HOME und Path fest:

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

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

Installation prüfen:
```
java -version
```

Build-Automatisierungstool installieren

Apache Maven, Gradle und SBT sind Paketverwaltungsoptionen, mit denen Java-App-Abhängigkeiten schnell und konsistent plattformübergreifend erstellt werden können.

gcloud-CLI installieren

Die gcloud CLI ist eine Reihe von Tools für Google Cloud. Es enthält gcloud und bq, mit denen Sie über die Befehlszeile auf Compute Engine, Cloud Storage, BigQuery und andere Produkte und Dienste zugreifen können. Sie können diese Tools interaktiv oder in automatisierten Skripts ausführen.

(Optional) IDE oder Editor installieren

Beliebte Editoren (in keiner bestimmten Reihenfolge), die zum Entwickeln von Java-Anwendungen verwendet werden, sind unter anderem:

Visual Studio Code
IntelliJ IDEA und/oder Webstorm von JetBrains
Eclipse von Eclipse Foundation
Atom von GitHub

Diese Editoren bieten (teilweise mithilfe von Plug-ins) Funktionen, die von Syntaxhervorhebung, IntelliSense und Codevervollständigung bis hin zu vollständig integrierten Debugging-Funktionen reichen.

(Optional) IDE-Plug-in installieren

Um auf hilfreiche Funktionen in Ihrem Editor zuzugreifen, sehen Sie sich die folgenden Plug-ins an:

Cloud-Clientbibliotheken für Java installieren

Mit den Cloud-Clientbibliotheken für Java können Sie Google Cloud-Dienste wie Datastore und Cloud Storage einbinden. Sie können das Paket für eine einzelne API wie BigQuery installieren, wie im folgenden Beispiel gezeigt.

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:

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

Authentifizierung einrichten

Um die Clientbibliothek ausführen zu können, müssen Sie zuerst die Authentifizierung einrichten.

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.

Weitere Informationen finden Sie unter Für die Verwendung von Clientbibliotheken authentifizieren.

Clientbibliothek verwenden

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

Endpunkte für die Clientbibliothek konfigurieren

Wenn Sie APIs verwenden, die regionale Endpunkte unterstützen, können Sie mit Endpunkten konfigurieren, an welchen Server Anfragen gesendet werden sollen. Mit der Google.Cloud.Dataproc.V1 API können Sie beispielsweise einen Clientendpunkt konfigurieren. Weitere Informationen zu regionalen Endpunkten für Dataproc Ersetzen Sie im folgenden Beispiel MY-PROJECT durch Ihren Projektnamen und us-central1 durch die für Ihre Konfiguration geeignete Region:

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

Nächste Schritte

(Optional) Maven- oder Gradle-Plug-in für App Engine verwenden

Wenn Sie Dienste in der App Engine-Umgebung (Standardumgebung oder flexible Umgebung) entwickeln, können Sie Plug-ins für sowohl Apache Maven- als auch Gradle-Build-Tools verwenden, die praktische Funktionen zum Entwickeln, Testen und Bereitstellen Ihrer Apps bieten.

Für App Engine-Standardumgebungen

Verwenden Sie das Maven App Engine-Plug-in oder das Gradle-Plug-in für App Engine-Standardumgebungen.

Für flexible App Engine-Umgebungen

Verwenden Sie das Maven App Engine-Plug-in oder Gradle-Plug-in für flexible App Engine-Umgebungen.

Weitere Ressourcen

Dokumentation für Google Cloud -Produkte ansehen
Klonen Sie das Java-Beispielrepository von GitHub.