So installierst du GlassFish JAVA Application Server unter Ubuntu 22.04

Glassfish ist ein freier und quelloffener Server, der für die Bereitstellung von Java-basierten Anwendungen verwendet wird. Er ermöglicht es Entwicklern, Unternehmensanwendungen zu entwickeln, die bequem und skalierbar sind. Das Glassfish-Projekt wurde von Sun Microsystem ins Leben gerufen und wird jetzt von der Oracle Corporation gesponsert. Es unterliegt zwei freien Softwarelizenzen, der Common Development and Distribution License und der GNU General Public License.

In diesem Beitrag zeigen wir dir, wie du den Glassfish-Server mit Nginx als Reverse Proxy auf Ubuntu 22.04 installierst.

Voraussetzungen

  • Ein Server, auf dem Ubuntu 22.04 läuft.
  • Ein gültiger Domainname, der auf die IP deines Servers zeigt.
  • Ein Root-Passwort ist auf dem Server konfiguriert.

Java JDK installieren

Glassfish ist eine Java-basierte Anwendung. Daher musst du Java JDK auf deinem Server installieren. Du kannst es installieren, indem du den folgenden Befehl ausführst:

apt-get install default-jdk unzip -y

Sobald Java installiert ist, überprüfst du die Java-Version mit folgendem Befehl:

java --version

Du erhältst die Java-Version in der folgenden Ausgabe:

openjdk 11.0.15 2022-04-19
OpenJDK Runtime Environment (build 11.0.15+10-Ubuntu-0ubuntu0.22.04.1)
OpenJDK 64-Bit Server VM (build 11.0.15+10-Ubuntu-0ubuntu0.22.04.1, mixed mode, sharing)

Glassfish Server herunterladen

Zuerst musst du Glassfish von der offiziellen Download-Seite herunterladen. Du kannst ihn mit dem folgenden Befehl herunterladen:

wget https://download.eclipse.org/ee4j/glassfish/glassfish-6.1.0.zip

Sobald der Download abgeschlossen ist, entpackst du die heruntergeladene Datei in das Verzeichnis /opt:

unzip glassfish-6.1.0.zip -d /opt/

Eine Systemd-Dienstdatei für Glassfish erstellen

Als Nächstes musst du eine systemd-Dienstdatei erstellen, um den Glassfish-Dienst zu verwalten. Du kannst sie mit dem folgenden Befehl erstellen:

nano /usr/lib/systemd/system/glassfish.service

Füge die folgenden Zeilen hinzu:

[Unit]
Description = GlassFish Server v6.1.0
After = syslog.target network.target

[Service]
User = root
ExecStart = /usr/bin/java -jar /opt/glassfish6/glassfish/lib/client/appserver-cli.jar start-domain
ExecStop = /usr/bin/java -jar /opt/glassfish6/glassfish/lib/client/appserver-cli.jar stop-domain
ExecReload = /usr/bin/java -jar /opt/glassfish6/glassfish/lib/client/appserver-cli.jar restart-domain
Type = forking

[Install]
WantedBy = multi-user.target

Speichere und schließe die Datei und lade den systemd-Daemon neu, um die Änderungen zu übernehmen.

systemctl daemon-reload

Als Nächstes startest du den Glassfish-Dienst und aktivierst, dass er beim Neustart des Systems gestartet wird:

systemctl start glassfish
systemctl enable glassfish

Du kannst den Status des Glassfish-Dienstes auch mit dem folgenden Befehl überprüfen:

systemctl status glassfish

Du solltest die folgende Ausgabe sehen:

? glassfish.service - GlassFish Server v6.1.0
     Loaded: loaded (/lib/systemd/system/glassfish.service; disabled; vendor preset: enabled)
     Active: active (running) since Thu 2022-05-12 15:39:16 UTC; 4s ago
    Process: 5313 ExecStart=/usr/bin/java -jar /opt/glassfish6/glassfish/lib/client/appserver-cli.jar start-domain (code=exited, status=0/SUC>
   Main PID: 5326 (java)
      Tasks: 92 (limit: 2292)
     Memory: 289.3M
        CPU: 12.563s
     CGroup: /system.slice/glassfish.service
             ??5326 /usr/lib/jvm/java-11-openjdk-amd64/bin/java -cp /opt/glassfish6/glassfish/modules/glassfish.jar -XX:+UnlockDiagnosticVMOp>

May 12 15:39:04 ubuntu systemd[1]: Starting GlassFish Server v6.1.0...
May 12 15:39:16 ubuntu java[5313]: Waiting for domain1 to start ..........
May 12 15:39:16 ubuntu java[5313]: Successfully started the domain : domain1
May 12 15:39:16 ubuntu java[5313]: domain  Location: /opt/glassfish6/glassfish/domains/domain1
May 12 15:39:16 ubuntu java[5313]: Log File: /opt/glassfish6/glassfish/domains/domain1/logs/server.log
May 12 15:39:16 ubuntu java[5313]: Admin Port: 4848
May 12 15:39:16 ubuntu java[5313]: Command start-domain executed successfully.
May 12 15:39:16 ubuntu systemd[1]: Started GlassFish Server v6.1.0.

Passwort für Glassfish festlegen und Secure Login aktivieren

Standardmäßig hat der administrative Benutzer von Glassfish kein Passwort. Du musst es also zuerst festlegen. Du kannst es mit folgendem Befehl festlegen:

/opt/glassfish6/bin/asadmin --port 4848 change-admin-password

Du wirst aufgefordert, einen Benutzernamen anzugeben:

Enter admin user name [default: admin]>admin

Gib admin als Benutzernamen ein und drücke die Eingabetaste. Du wirst aufgefordert, ein Passwort einzugeben:

Enter the admin password> 

Drücke einfach die Eingabetaste, ohne etwas einzutippen. Du wirst gefragt, ob du ein neues Passwort festlegen möchtest:

Enter the new admin password> 
Enter the new admin password again> 

Gib dein neues Passwort ein und drücke die Eingabetaste, um das Passwort festzulegen.

Command change-admin-password executed successfully.

Als Nächstes musst du auch die sichere Anmeldung aktivieren. Du kannst sie mit dem folgenden Befehl aktivieren:

/opt/glassfish6/bin/asadmin --port 4848 enable-secure-admin

Du wirst aufgefordert, einen Admin-Benutzer und ein Passwort anzugeben, um die sichere Anmeldung zu aktivieren.

Enter admin user name>  admin
Enter admin password for user "admin"> 
You must restart all running servers for the change in secure admin to take effect.
Command enable-secure-admin executed successfully.

Starte anschließend den Glassfish-Dienst neu, um die Änderungen zu übernehmen:

systemctl restart glassfish

Nginx als Reverse Proxy für Glassfish konfigurieren

Als Nächstes musst du Nginx als Reverse-Proxy für Glassfish installieren und konfigurieren. Installiere zunächst den Nginx-Server mit dem folgenden Befehl:

apt-get install nginx -y

Sobald Nginx installiert ist, erstellst du eine Konfigurationsdatei für den virtuellen Nginx-Host:

nano /etc/nginx/conf.d/glassfish.conf

Füge die folgende Konfiguration hinzu:

upstream glassfish {
  server 127.0.0.1:8080 weight=100 max_fails=5 fail_timeout=5;
}

server {
  listen          80;
  server_name     glassfish.example.com;

  location / {
        proxy_set_header X-Forwarded-Host $host;
        proxy_set_header X-Forwarded-Server $host;
        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
        proxy_pass http://glassfish/hello/;
  }
}

Speichere und schließe die Datei, wenn du fertig bist. Überprüfe dann Nginx mit folgendem Befehl auf Syntaxfehler in der Konfiguration:

nginx -t

Wenn alles in Ordnung ist, erhältst du die folgende Ausgabe:

nginx: the configuration file /etc/nginx/nginx.conf syntax is ok
nginx: configuration file /etc/nginx/nginx.conf test is successful

Starte als Nächstes den Nginx-Dienst neu, um die Änderungen zu übernehmen:

systemctl restart nginx

Du kannst den Status von Nginx auch mit dem folgenden Befehl überprüfen:

systemctl status nginx

Du solltest die folgende Ausgabe sehen:

? nginx.service - A high performance web server and a reverse proxy server
     Loaded: loaded (/lib/systemd/system/nginx.service; enabled; vendor preset: enabled)
     Active: active (running) since Thu 2022-05-12 16:09:38 UTC; 6s ago
       Docs: man:nginx(8)
    Process: 5687 ExecStartPre=/usr/sbin/nginx -t -q -g daemon on; master_process on; (code=exited, status=0/SUCCESS)
    Process: 5689 ExecStart=/usr/sbin/nginx -g daemon on; master_process on; (code=exited, status=0/SUCCESS)
   Main PID: 5690 (nginx)
      Tasks: 2 (limit: 2292)
     Memory: 2.6M
        CPU: 39ms
     CGroup: /system.slice/nginx.service
             ??5690 "nginx: master process /usr/sbin/nginx -g daemon on; master_process on;"
             ??5691 "nginx: worker process" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" ""

May 12 16:09:38 ubuntu systemd[1]: Starting A high performance web server and a reverse proxy server...
May 12 16:09:38 ubuntu systemd[1]: Started A high performance web server and a reverse proxy server.

UFW-Firewall konfigurieren

Aus Sicherheitsgründen ist es empfehlenswert, die UFW-Firewall in deinem System zu installieren und zu konfigurieren. Installiere zunächst die UFW-Firewall mit dem folgenden Befehl:

apt install ufw -y

Sobald die UFW-Firewall installiert ist, erlaubst du alle erforderlichen Ports und Dienste mit dem folgenden Befehl:

ufw allow 'Nginx Full'
ufw allow OpenSSH
ufw allow 4848/tcp
ufw allow 8080/tcp

Aktiviere dann die UFW-Firewall, damit sie nach dem Neustart des Systems startet:

ufw enable

Du kannst nun den Status der UFW-Firewall mit folgendem Befehl überprüfen:

ufw status

Du erhältst die folgende Ausgabe:

Status: active

To                         Action      From
--                         ------      ----
OpenSSH                    ALLOW       Anywhere                  
Nginx Full                 ALLOW       Anywhere                  
8080/tcp                   ALLOW       Anywhere                  
4848/tcp                   ALLOW       Anywhere                  
OpenSSH (v6)               ALLOW       Anywhere (v6)             
Nginx Full (v6)            ALLOW       Anywhere (v6)             
8080/tcp (v6)              ALLOW       Anywhere (v6)             
4848/tcp (v6)              ALLOW       Anywhere (v6)             

Zugriff auf Glassfish Web Interface

Du kannst nun auf Glassfish zugreifen, indem du die URL http://glassfish.example.com verwendest . Du solltest die folgende Seite sehen:

GlassFish

Um auf die Glassfish-Administrationsoberfläche zuzugreifen, gib die URL https://your-server-ip:4848 ein. Du wirst auf die Glassfish-Anmeldeseite weitergeleitet:

GlassFish Anmeldung

Gib deinen Admin-Benutzernamen und dein Passwort ein und klicke auf die Schaltfläche Login. Auf der folgenden Seite solltest du das Glassfish-Dashboard sehen:

Eclipse GlassFish Dashboard

Klicke auf den Server im linken Bereich. Du solltest die Seite mit den allgemeinen Informationen sehen.

Allgemeine Informationen

Hier kannst du den Glassfish-Server starten, stoppen und überwachen.

Klicke auf die Knoten im linken Bereich. Auf der folgenden Seite solltest du den Glassfish-Knoten sehen.

Knotenpunkte

Klicke auf die Anwendungen im linken Fensterbereich. Auf der folgenden Seite solltest du alle deine eingesetzten Anwendungen sehen.

Anwendungen

Fazit

In diesem Beitrag haben wir dir erklärt, wie du den Glassfish-Server mit Nginx als Reverse Proxy auf Ubuntu 22.04 installierst. Jetzt kannst du damit beginnen, die Java-Anwendung mit dem Glassfish-Server zu installieren. Wenn du noch Fragen hast, kannst du dich gerne an mich wenden.

Das könnte dich auch interessieren …