Einrichten eines Java-Projekts für GitHub Codespaces

Einführung

In diesem Leitfaden wird beispielhaft veranschaulicht, wie du ein Java-Projekt in in GitHub Codespaces mithilfe des Visual Studio Code-Webclients. Du findest dort ausführliche Informationen zum Öffnen deines Projekts in einem Codespace und zum Hinzufügen und Ändern einer vordefinierten Entwicklungscontainerkonfiguration.

Nachdem du dieses Tutorial abgeschlossen hast, kannst du deinem eigenen Repository mithilfe des VS Code-Webclients oder der VS Code-Desktopanwendung eine Entwicklungscontainerkonfiguration hinzufügen.

Weitere Informationen zu Entwicklungscontainern findest du unter Einführung in Entwicklungscontainer. einrichtest.

Schritt 1: Öffnen des Projekts in einem Codespace

1. Gehe zu https://github.com/microsoft/vscode-remote-try-java.

2. Klicke auf Diese Vorlage verwenden und dann auf In einem Codespace öffnen.

   

Wenn du einen Codespace erstellst, wird dein Projekt auf einer Remote-VM erstellt, die dir zugewiesen ist. Der Container für deinen Codespace verfügt standardmäßig über viele Sprachen und Runtimes (einschließlich Java). Er enthält außerdem häufig verwendete Tools wie Gradle, Maven, Git, Wget, rsync, OpenSSH und nano.

Du kannst deinen Codespace anpassen, indem du die Anzahl der vCPUs und den RAM anpassst, Dotfiles zum Personalisieren deiner Umgebung hinzufügst oder die installierten Tools und Skripts bearbeitest. Weitere Informationen findest du unter Anpassen des Codespace.

GitHub Codespaces verwendet eine Datei namens devcontainer.json, um den Entwicklungscontainer zu konfigurieren, mit dem du in einem Codespace arbeitest. Jedes Repository kann eine oder mehrere devcontainer.json-Dateien enthalten, sodass du genau die Entwicklungsumgebung erhältst, die du zum Arbeiten an deinem Code in einem Codespace benötigst.

Beim Starten verwendet GitHub Codespaces eine devcontainer.json-Datei sowie alle davon abhängigen Dateien, aus denen die Entwicklungscontainerkonfiguration besteht, um Tools und Runtimes zu installieren und weitere für das Projekt erforderliche Einrichtungsaufgaben auszuführen. Weitere Informationen findest du unter Einführung in Entwicklungscontainer.

Schritt 2: Hinzufügen einer Entwicklungscontainerkonfiguration

Der Standardentwicklungscontainer für GitHub Codespaces ermöglicht die Arbeit an einem Java-Projekt wie vscode-remote-try-java. Es wird jedoch empfohlen, einen eigenen Entwicklungscontainer zu konfigurieren, der alle Tools und Skripts enthält, die für dein Projekt erforderlich sind. Dadurch wird eine vollständig reproduzierbare Umgebung für alle GitHub Codespaces-Benutzer in deinem Repository bereitgestellt.

Wenn du dein Repository so einrichten möchtest, dass ein benutzerdefinierter Entwicklungscontainer verwendet wird, musst du eine oder mehrere devcontainer.json-Datei(en) erstellen. Du kannst diese entweder aus einer vordefinierten Konfigurationsvorlage in Visual Studio Code hinzufügen oder selbst schreiben. Weitere Informationen zur Konfiguration von Entwicklungscontainern findest du unter Einführung in Entwicklungscontainer. 1. Greife auf die Visual Studio Code Command Palette (UMSCHALT+COMMAND+P / STRG+UMSCHALT+P) zu, und beginne dann mit der Eingabe von „Entwicklungscontainer“. Klicke auf Codespaces: Entwicklungscontainer konfigurieren.

1. Klicke auf Ganz von vorn beginnen.

2. In diesem Beispiel enthält das Vorlagenrepository, aus dem du den Codespace erstellt hast, bereits eine Entwicklungscontainerkonfiguration, sodass eine Meldung angezeigt wird, dass die Konfigurationsdatei bereits vorhanden ist. Da du die vorhandene Konfigurationsdatei überschreiben möchtest, klickst du auf Weiter.

3. Klicke auf Alle Definitionen anzeigen.

   

4. Gib java ein, und klicke auf die Option Java. Andere Optionen sind verfügbar, wenn dein Projekt bestimmte Tools verwendet, zum Beispiel Java und PostgreSQL.

   

5. Wähle die Java-Version aus, die du für dein Projekt verwenden möchtest. Wähle in diesem Fall die als Standard markierte Version aus.

   

6. Wähle die Option Maven installieren aus, und klicke auf OK.

   

7. Es wird eine Liste der zusätzlich installierbaren Features angezeigt. Installiere Ant, die Java-Bibliothek und das Befehlszeilentool für die Anwendungskompilierung. Um dieses Feature zu installieren, gib ant ein, wähle Ant (via SDKMAN) aus, und klicke dann auf OK.

   

8. Es wird eine Meldung angezeigt, dass die Konfigurationsdatei des Entwicklungscontainers bereits vorhanden ist. Klicke auf Überschreiben.

   Es wird eine Datei devcontainer.json erstellt und im Editor geöffnet. ### Details zur Konfiguration deines benutzerdefinierten Entwicklungscontainers

Wenn du im Visual Studio Code-Explorer nachschaust, wird dir angezeigt, dass dem Stammverzeichnis des Repositorys deines Projekts, das die Datei devcontainer.json enthält, ein Verzeichnis .devcontainer hinzugefügt wurde. Dies ist die Hauptkonfigurationsdatei für Codespaces, die aus diesem Repository erstellt werden.

devcontainer.json

Die von dir hinzugefügte Datei devcontainer.json enthält Werte für die Eigenschaften name, image und features. Einige zusätzliche Eigenschaften, die du möglicherweise nützlich findest, sind zwar enthalten, aber auskommentiert.

Die Datei sollte in etwa wie folgt aussehen, je nachdem, welches Image du ausgewählt hast:

// For format details, see https://aka.ms/devcontainer.json. For config options, see the
// README at: https://github.com/devcontainers/templates/tree/main/src/java
{
  "name": "Java",
  // Or use a Dockerfile or Docker Compose file. More info: https://containers.dev/guide/dockerfile
  "image": "mcr.microsoft.com/devcontainers/java:0-17",

  "features": {
    "ghcr.io/devcontainers/features/java:1": {
      "version": "none",
      "installMaven": "true",
      "installGradle": "false"
    },
    "ghcr.io/devcontainers-contrib/features/ant-sdkman:2": {}
  }

  // Use 'forwardPorts' to make a list of ports inside the container available locally.
  // "forwardPorts": [],

  // Use 'postCreateCommand' to run commands after the container is created.
  // "postCreateCommand": "java -version",

  // Configure tool-specific properties.
  // "customizations": {},

  // Uncomment to connect as root instead. More info: https://aka.ms/dev-containers-non-root.
  // "remoteUser": "root"
}

• name: Du kannst deinem Entwicklungscontainer einen beliebigen Namen geben. Es wird ein Standardwert bereitgestellt.
• image: Der Name eines Images in einer Containerregistrierung (DockerHub, GitHub Container registry oder Azure Container Registry), der zum Erstellen des Entwicklungscontainers für den Codespace verwendet wird.
• features: Eine Liste mit mindestens einem Objekt, von denen jedes auf eine der verfügbaren Entwicklungscontainerfunktionen verweist. Funktionen sind eigenständige, gemeinsam nutzbare Einheiten des Installationscodes und der Konfiguration des Entwicklungscontainers. Sie bieten eine einfache Möglichkeit, deinem Entwicklungscontainer weitere Tools, Runtime- oder Bibliotheksfunktionen hinzuzufügen. Weitere Informationen findest du unter Verfügbare Entwicklungscontainerfunktionen auf der Website für Entwicklungscontainer. Du kannst Features hinzufügen, indem du zu VS Code Command Palette wechselst und features eingibst.
• forwardPorts: Alle hier aufgeführten Ports werden automatisch weitergeleitet. Weitere Informationen findest du unter Weiterleiten von Ports in deinem Codespace. - postCreateCommand: Verwende diese Eigenschaft, um Befehle auszuführen, nachdem dein Codespace erstellt wurde.
• customizations: Mit dieser Eigenschaft kannst du ein bestimmtes Tool oder einen bestimmten Dienst anpassen, wenn dieses oder dieser für die Arbeit in einem Codespace verwendet wird. Du kannst beispielsweise bestimmte Einstellungen und Erweiterungen für VS Code konfigurieren. Weitere Informationen findest du unter Unterstützende Tools und Dienste auf der Website für Entwicklungscontainer.
• remoteUser: Du führst Vorgänge standardmäßig als Visual Studio Code-Benutzer*in aus. Du kannst diese Option aber auch auf das Stammverzeichnis festlegen.

Eine vollständige Liste der verfügbaren Eigenschaften findest du in der Spezifikation für Entwicklungscontainer auf der Website für Entwicklungscontainer.

Zusätzliche Konfigurationsdateien für Entwicklungscontainer

Wenn du mit Docker vertraut bist, kannst du zusätzlich zur Datei devcontainer.json auch ein Dockerfile oder Docker Compose verwenden, um deine Codespaceumgebung zu konfigurieren. Dazu kannst du deine Dateien Dockerfile oder docker-compose.yml zusammen mit der Datei devcontainer.json hinzufügen. Weitere Informationen findest du unter Verwenden von Images, Dockerfiles und Docker Compose auf der Website für Entwicklungscontainer.

Schritt 3: Bearbeite die Datei „devcontainer.json“.

Mit der hinzugefügten Entwicklungscontainerkonfiguration und einem grundlegenden Verständnis der Funktionen kannst du nun Änderungen vornehmen, um deine Umgebung weiter anzupassen. In diesem Beispiel fügst du Eigenschaften hinzu, die Folgendes bewirken:

• Ausführung eines Befehls, nachdem der Entwicklungscontainer erstellt wurde, um eine neue Datei zu erstellen
• Automatische Installation von zwei VS Code-Erweiterungen in diesem Codespace

1. Füge in der Datei devcontainer.json ein Komma nach der Eigenschaft features hinzu.

   JSON

   "features": {
     "ghcr.io/devcontainers/features/java:1": {
       "version": "none",
       "installMaven": "true",
       "installGradle": "false"
     },
     "ghcr.io/devcontainers-contrib/features/ant-sdkman:2": {}
   },

2. Hebe die Auskommentierung der Eigenschaft postCreateCommand auf, und ändere ihren Wert in echo \"This file was added by the postCreateCommand.\" > TEMP.md.

   JSON

   // Use 'postCreateCommand' to run commands after the container is created.
   "postCreateCommand": "echo \"This file was added by the postCreateCommand.\" > TEMP.md",

3. Hebe die Auskommentierung der Eigenschaft customizations auf, und bearbeite sie wie folgt, um die Erweiterung „Rechtschreibprüfung für Codeanalyse“ und das Erweiterungspaket für Java zu installieren.

   JSON

   // Configure tool-specific properties.
   "customizations": {
     // Configure properties specific to VS Code.
     "vscode": {
       // Add the IDs of extensions you want installed when the container is created.
       "extensions": [
         "streetsidesoftware.code-spell-checker",
         "vscjava.vscode-java-pack"
       ]
     }
   }

   Die devcontainer.json-Datei sollte nun in etwa wie folgt aussehen, je nachdem, welches Image du ausgewählt hast:

   // For format details, see https://aka.ms/devcontainer.json. For config options, see the
   // README at: https://github.com/devcontainers/templates/tree/main/src/java
   {
     "name": "Java",
     // Or use a Dockerfile or Docker Compose file. More info: https://containers.dev/guide/dockerfile
     "image": "mcr.microsoft.com/devcontainers/java:0-17",
   
     "features": {
       "ghcr.io/devcontainers/features/java:1": {
         "version": "none",
         "installMaven": "true",
         "installGradle": "false"
       },
       "ghcr.io/devcontainers-contrib/features/ant-sdkman:2": {}
     },
   
     // Use 'forwardPorts' to make a list of ports inside the container available locally.
     // "forwardPorts": [],
   
     // Use 'postCreateCommand' to run commands after the container is created.
     "postCreateCommand": "echo \"This file was added by the postCreateCommand.\" > TEMP.md",
   
     // Configure tool-specific properties.
     "customizations": {
       // Configure properties specific to VS Code.
       "vscode": {
         // Add the IDs of extensions you want installed when the container is created.
         "extensions": [
           "streetsidesoftware.code-spell-checker",
           "vscjava.vscode-java-pack"
         ]
       }
     }
   
     // Uncomment to connect as root instead. More info: https://aka.ms/dev-containers-non-root.
     // "remoteUser": "root"
   }
   

4. Speichern Sie die Änderungen. 1. Greife auf die VS Code Command Palette (UMSCHALT+COMMAND+P / STRG+UMSCHALT+P) zu, und beginne dann mit der Eingabe von „rebuild“. Klicke auf Codespaces: Container neu erstellen.

   

   Tipp: Führe gelegentlich eine vollständige Neuerstellung durchführen, um deinen Cache zu löschen und deinen Container mit neuen Images neu zu erstellen. Weitere Informationen findest du unter Durchführen einer vollständigen Neuerstellung eines Containers.

   Durch das Neuerstellen innerhalb deines Codespace wird sichergestellt, dass die Änderungen wie erwartet funktionieren, bevor du einen Commit für die Änderungen im Repository ausführst. Wenn etwas zu einem Fehler führt, wirst du in einem Codespace mit einem Wiederherstellungscontainer platziert, den du neu erstellen kannst, um deinen Container weiter anzupassen.

   Wenn der Entwicklungscontainer neu erstellt wurde und dein Codespace wieder verfügbar ist, wurde postCreateCommand bereits ausgeführt, wobei eine TEMP.md-Datei erstellt wurde, und die zwei Erweiterungen sind einsatzbereit.

Schritt 4: Ausführen der Anwendung

1. Führe die Anwendung aus, indem du F5 drückst.

2. In der unteren rechten Ecke von VS Code sollte eine Popupbenachrichtigung angezeigt werden, in der du gefragt wirst, ob du zum Standardmodus wechseln möchtest. Klicke auf Ja.

   

3. Wenn die Projektdateien importiert wurden, klicke auf die Registerkarte Debugging-Konsole, um die Programmausgabe anzuzeigen.

   

Schritt 5: Committen der Änderungen

Nachdem du Änderungen an deinem Codespace vorgenommen hast (neuer Code oder Konfigurationsänderungen), solltest du deine Änderungen committen. Durch das Committen von Änderungen an dein Repository wird sichergestellt, dass alle Benutzerinnen, die einen Codespace aus diesem Repository erstellen, die gleiche Konfiguration verwenden. Alle von dir vorgenommenen Anpassungen, z. B. das Hinzufügen von VS Code-Erweiterungen stehen dann allen Benutzerinnen zur Verfügung.

In diesem Tutorial hast du einen Codespace aus einem Vorlagenrepository erstellt, sodass der Code in deinem Codespace noch nicht in einem Repository gespeichert ist. Du kannst ein Repository erstellen, indem du den aktuellen Branch auf GitHub.com veröffentlichst.

Informationen findest du unter Verwenden der Quellcodeverwaltung in deinem Codespace.

Nächste Schritte

Du solltest nun in der Lage sein, einem eigenen Java-Projekt eine benutzerdefinierte Entwicklungscontainerkonfiguration hinzuzufügen.

Im Folgenden findest du einige zusätzliche Ressourcen für erweiterte Szenarios:

• Verwalten verschlüsselter Geheimnisse für Codespaces
• Nachdem du die GPG-Überprüfung aktiviert hast, signiert GitHub automatisch Commits, die du in GitHub Codespaces ausführst, und die Commits weisen in GitHub den Status „Überprüft“ auf.
• Weiterleiten von Ports in deinem Codespace