Einleitung

Du suchst nach einer einfachen Möglichkeit, deine Anwendung bereitzustellen und sie im Web zu präsentieren?
Hier findest du eine Schritt-für-Schritt-Anleitung, wie du deine eigene "always-free" virtuelle Maschine erstellen, einen Container bereitstellen und ihn sogar sicher über https zugänglich machen kannst.
Die Technologien, die wir verwenden werden, sind:

• Oracle Cloud mit einer Oracle Linux Arm VM
• Docker für den Container
• Angular (Sie können beliebige statische HTML-Dateien verwenden)
• Caddy als Webserver

Erster Schritt: Hole dir deine eigene persönliche Domain

Um eine sichere Verbindung zu ermöglichen, musst du dir eine eigene Domain zulegen. Dies ist der einzige Teil dieses Beitrags, bei dem du wahrscheinlich bezahlen musst. Aber keine Sorge, es sind nur etwa 7€/Jahr.
Ich habe Google Domains verwendet, aber du kannst auch jeden anderen Anbieter verwenden. Der Eintrag sollte vom Typ A sein.

Erstelle deine eigene virtuelle Maschine von Oracle

Als erstes musst du einen Account erstellen.Mit dem Oracle Cloud free tier gibt es viele Möglichkeiten, kostenlose Datenbanken, Load Balancer, uvm. Wir werden nur die virtuelle Maschine nutzen. Nachdem du dich eingeloggt hast, wirst du vermutlich die 'Get Started' Seite sehen. Klicke hier nun auf 'Create a VM Instance'.

! Wichtig !Stell sicher, dass du nur 'Always Free-eligible' Optionen nutzt.Es werden dennoch Kosten von 2$ für einen 'block storage' angezeigt. Diese Summe wird dir aber nicht berechnet - es scheint sich um einen Bug von Oracle zu handeln. Hoffentlich wird dieser bereits gefixt sein, wenn du den Artikel liest. Als Image nutze ich Oracle Linux 8 und als Shape den VM.Standard.E2.1.Micro mit den maximalen Ressourcen, welche du im free tier bekommen kannst.

Im Abschnitt Networking musst du nun dein eigenes virtuelles Cloud-Netzwerk (VCN) und Subnetz erstellen.
Weise eine öffentliche IPv4-Adresse zu. Diese wird benötigt, wenn du deine eigene Anwendung veröffentlichen willst.
Alles andere bleibt dir überlassen.
Ich würde empfehlen, einen SSH-Schlüssel auf deinem Computer mit ssh-keygen -t rsa zu erstellen und die .pub-Datei hochzuladen, während du die VM erstellst.
In den Abschnitten Boot-Volume und Live-Migration habe ich alles auf Standard gesetzt.
Klicke nun auf 'Erstellen'.

Veröffentliche die virtuelle Maschine

Je nachdem, ob du deine virtuelle Maschine über http, https oder beides erreichen willst, müssen Ingress Rules erstellt werden.
Gehe dazu in dein virtuelles Cloud-Netzwerk und öffne das Subnetz, das verwendet werden soll.
Hier kannst du Security Lists hinzufügen. Es sollte jedoch bereits eine Standard Security List vorhanden sein. Öffne diese und klicke auf 'Add Ingress Rules'.

Füge '0.0.0.0/0' als Source-CIDR hinzu und wähle als Destination-Port 80 für http, 443 für https oder beides.

Verbinde dich mit der virtuellen Maschine

Jetzt ist es an der Zeit, das Innere der virtuellen Maschine kennenzulernen.
Du kannst entweder die in Oracle Cloud bereitgestellte Shell verwenden oder dich direkt von deinem Computer aus über SSH verbinden.
Ändere dafür zunächst die Rechte des SSH-Keys, den du bei der Erstellung in die VM hochgeladen hast.


chmod 400 ~/.ssh/id_rsa
Verwende den ssh Key dann, um dich via Terminal mit der virtuellen Maschine zu verbinden.Du findest den username (der Default ist opc) und die public IP Adresse, wenn du deine VM Instanz in Oracle Cloud öffnest.
ssh -i ~/.ssh/id_rsa 'username'@'public-ip'


Willkommen!

Ändere deine Nutzerrechte permanent für eine Session:


sudo su


Installiere Docker auf der virtuellen Maschine

Oracle Linux basiert auf Fedora Linux. Daher werden wir den DNF-Paketmanager verwenden.


dnf install -y dnf-utils zip unzip<br>    dnf config-manager --add-repo=https://download.docker.com/linux/centos/docker-ce.repo<br>    dnf remove -y runc<br>    dnf install -y docker-ce --nobest


Beende den Docker Setup

systemctl enable docker.service<br>    systemctl start docker.service


Klicke hier für mehr Informationen über diese Befehle.

Logge dich bei Docker ein


echo $PASSWORD | sudo docker login $DOCKER_DOMAIN -u $USERNAME --password-stdin


Erstelle deinen eigenen Container

Zur Demonstration verwende ich ein Angular-Frontend und einen NGINX-Container. Aber jeder Docker-Container ist für diesen Anwendungsfall geeignet.

Erstelle ein Angular-Projekt mit:


ng new oracle-cloud-frontend


Dann füge eine 'nginx.conf' und ein 'Dockerfile' hinzu:


# nginx.conf<br>server {<br>    listen 80;<br>    server_name _;<br>    root /usr/share/nginx/html;<br>    location / {<br>        try_files $uri $uri/ /index.html =404;<br>    }<br>    location /health {<br>        access_log off;<br>        return 200 'up';<br>    }<br>    location /nginx_status {<br>        stub_status;<br>        access_log off;<br>        allow 127.0.0.1;<br>        deny all;<br>    }<br>}<br>

# Dockerfile<br>FROM nginx:1.24<br>COPY /dist /usr/share/nginx/html<br>COPY /deployment/nginx.conf /etc/nginx/conf.d/default.conf<br># Expose the default HTTP port<br>EXPOSE 80<br># Start Nginx when the container launches<br>CMD ["nginx", "-g", "daemon off;"]<br>


Jetzt solltest du dein Projekt mit Docker bauen können:


docker build . -t $IMAGE_TAG


Starte den Container

Der einfachste Weg, den Container auf deine virtuelle Maschine zu bekommen, ist, ihn mit 'docker push' in eine Container-Registry wie Docker Hub oder Github Packages hochzuladen.

Gehe dann zu deiner VM und ziehe das Image. Vergiss nicht, dass du hierfür eingeloggt sein müsst.


docker pull $IMAGE_TAG


Starte nun den Container an dem Port, den du verwenden möchtest.

Der NGINX-Frontend-Container, den wir einsetzen werden, läuft auf Port 80, aber aus Gründen der Erweiterbarkeit wollen wir auf Port 4200 veröffentlichen. Wenn der Container im Hintergrund gestartet werden soll, verwende die Option -d.


docker run -p 4200:80 -d $IMAGE_TAG<br>


Beim Ausführen von 'docker ps' solltest du nun mindestens einen Container sehen, welcher auf ports '0.0.0.0:4200->80/tcp' läuft.

Glückwunsch!

Du kannst nun deine App im Browser öffnen. Gib hierfür die IP der virtuellen Maschine und dein Port des Containers ein.

z.B. 'http://{your_public_ip}:4200'.

Sichere die Anwendung mit HTTPS

Der nächste Schritt betrifft die Domain, die du am Anfang dieses Beitrags erstellt hast. Gehe zum DNS-Bereich deines Providers und verbinde die Domain mit der öffentlichen IP deiner VM.

Um zu testen, ob alles richtig gemacht wurde, öffne 'http://deine_domain:4200' in deinem Browser. Wenn du die gleiche Anwendung siehst, die auch auf 'http://deine_public_ip:4200' verfügbar ist, hast du es geschafft.

Aber wie kann man auf einfache Weise eine sichere Verbindung über https herstellen? Die Antwort ist Caddy.
Installiere nun den Caddy-Webserver auf der virtuellen Maschine.


dnf install 'dnf-command(copr)'<br>dnf copr enable @caddy/caddy<br>dnf install caddy


Unter '/etc/caddy' solltest du nun ein sogenanntes Caddyfile finden.
Wir wollen einen Reverse Proxy verwenden, um unseren Frontend-Container auf Port 4200 über unsere Domain zu erreichen.
Passe dein Caddyfile wie folgt an:


# Caddyfile<br>your_domain.com {<br> reverse_proxy localhost:4200<br>}


Caddy holt sich nun automatisch ein Zertifikat von let's encrypt und leitet von 'https://deine_domain.com' zu 'http://localhost:4200'  in deiner virtuellen Maschine.

Konfiguriere die Firewall

Zusätzlich zum veröffentlichen des Ports 443 in der Oracle Cloud UI musst du deine Firewall konfigurieren und neu starten:


firewall-cmd --zone=public --permanent --add-port=443/tcp<br>firewall-cmd --complete-reload


Und nicht zuletzt

Der letzte Schritt besteht darin, wieder in das Verzeichnis des Caddyfiles '/etc/caddy' zu gehen.
Führe dort folgenden Befehl aus:


caddy run


Öffne 'https://your_domain.com'  in deinem Browser. Du solltest zu deinem sicheren Frontend kommen.