Erstellen Sie plattformübergreifende Containerimages mit Podman auf Oracle Linux

Einführung

Diese Demo zeigt die Erstellung eines plattformübergreifenden Containerimages mit Podman unter Oracle Linux.

Ziele

In diesem Tutorial erfahren Sie, wie Sie:

Podman für Remotekonnektivität konfigurieren
Verbindung zu einer Remote-Podman-Instanz herstellen
Plattformspezifische Images aus einer einzelnen Containerdatei erstellen
Plattformspezifische Images in Oracle Cloud Infrastructure Registry (OCIR) übertragen
Erstellen einer Manifestliste, die beide plattformspezifische Images enthält
Manifestliste an OCIR übertragen
Prüfen Sie die OCIR-gehostete Manifestliste, um die verfügbaren Plattformen anzuzeigen
Bild abrufen und ausführen

Voraussetzungen

Zugriff auf einen Oracle Cloud Infrastructure-(OCI-)Mandanten
Eine Oracle Linux x86_64-Instanz
Eine aarch_64-Instanz für Oracle Cloud-Entwickler
Zugriff auf Oracle Cloud Infrastructure Registry

Podman-Server bereitstellen

Erstellen Sie eine Oracle Linux Compute-Instanz.

Sie können das Standardimage und die Standardausprägung verwenden, sofern die Ausprägung eine x86_64-Architektur verwendet. Wählen Sie ein öffentliches Subnetz aus, oder erstellen Sie es, und weisen Sie eine IPv4-Adresse zu.

Dieser Schritt unterstützt die Verwendung der Microausprägungen, die in Always Free Tier verfügbar sind.
Melden Sie sich bei der Instanz an, nachdem die Instanz ausgeführt wurde.
```
ssh -i <SSH_KEY> opc@<IP_ADDRESS_OF_PODMAN_SERVER_INSTANCE>
```
Dabei gilt:
- <SSH_KEY> ist der private Teil Ihres SSH-Schlüssels, der beim Provisioning der Compute-Instanz verwendet wird. Beispiel: ~/.ssh/id_rsa
- <IP_ADDRESS_OF_PODMAN_SERVER_INSTANCE> die öffentliche IP-Adresse der Compute-Instanz ist.

Installieren und Konfigurieren von Podman für Remotezugriff

Sie können diese Befehle als Standardbenutzeraccount opc auf der Compute-Instanz oder als Benutzer mit sudo-Zugriff ausführen.

Aktualisieren Sie das System mit den neuesten Sicherheitsfixes und Errata.
```
sudo dnf -y update
```
Installieren Sie die Podman-Packages oder -Module.

Oracle Linux 8:
```
sudo dnf module install -y container-tools:ol8
```
Oracle Linux 9 und Oracle Linux 10:
```
sudo dnf install -y container-tools
```
Das Container-Tool-Modul oder Paket installiert podman und andere Container-Tools, einschließlich skopeo und buildah. Ein wesentliches Package ist container-selinux, mit dem podman als Nicht-Root-Benutzer auf einem SELinux-fähigen System ausgeführt werden kann, das standardmäßig von Oracle Linux aktiviert ist.
Aktivieren Sie den Podman-Socket.

systemd horcht auf diesen Socket und startet eine Instanz von Podman, wenn ein Remote-Client ihn aktiviert. Wenn die Verbindung geschlossen wird, fährt systemd die Podman-Instanz herunter.

Hinweis: Es ist möglich, den Remote-Podman-Zugriff im Rootless-Modus zu konfigurieren. Dies liegt jedoch außerhalb des Anwendungsbereichs dieses Tutorials.
```
sudo systemctl enable --now podman.socket
```
Prüfen Sie den Pfad für das Socket.
```
sudo systemctl status podman.socket
```
Die Ausgabe zeigt das Socket-Listening an, und der Speicherort lautet /run/podman/podman.sock.

Das war's, aber bleiben Sie bei der Podman-Serverinstanz angemeldet, um die passwortlose SSH-Konfiguration später in diesem Tutorial auszuführen.

Oracle Cloud Developer-Instanz bereitstellen

Oracle Ampere A1 Compute ist eine leistungsstarke Plattform, die Oracle Cloud Infrastructure-(OCI-) und Ampere Altra Arm-Prozessoren kombiniert. Es bietet eine deterministische Performance, bewährte Sicherheit und ein breites Entwicklerökosystem, das gängige Tools und Umgebungen (OS, Kubernetes - OKE, SDKs und CLIs) umfasst.

OCI listet das Oracle Cloud Developer Image als Plattformimage mit allen gängigen Entwicklertools auf, einschließlich Git, Node.js, Java und GraalVM.

Erstellen Sie eine Compute-Instanz von Oracle Cloud Developer.

Wählen Sie das Oracle Cloud Developer-Image und eine Ampere-Ausprägung aus. Wählen Sie dasselbe öffentliche Subnetz wie die Podman-Serverinstanz aus, und weisen Sie eine IPv4-Adresse zu.
Entscheiden Sie sich, Ingress-Regeln oder SSH-Portweiterleitung zu verwenden.

Sie können auf zwei Arten auf die Demo-Webanwendung zugreifen, die wir erstellen. Sie können beides aktivieren, aber Sie müssen nur das eine oder das andere auswählen.

(Optional) Ingress-Regel erstellen

Die Verwendung einer Ingress-Regel ist ein zweistufiger Prozess. Diese Option öffnet den Zugriff auf das Subnetz über das Internet und gewährt weiterhin Zugriff auf die Instanz auf dem angegebenen Port, auch nach einem Neustart. Sie müssen zuerst die Regel in OCI erstellen und dann den Port in firewalld auf der Oracle Linux-Instanz öffnen.

Fügen Sie Ihrem öffentlichen Subnetz eine Ingress-Regel hinzu.

Die Regel muss eingehenden Traffic auf Port 5808/tcp von 0.0.0.0/0 zulassen. Die Regel wird unmittelbar nach der Erstellung wirksam.
Öffnen Sie ein neues Terminal, und stellen Sie über SSH eine Verbindung zur Oracle Cloud Developer-Instanz her.
```
ssh -i <SSH_KEY> opc@<IP_ADDRESS_OF_ORACLE_CLOUD_DEVELOPER_INSTANCE>
```

Zugriff auf die Demo-Webanwendung hinzufügen.

sudo firewall-cmd --permanent --add-port=5808/tcp
sudo firewall-cmd --reload

Bestätigen Sie die Änderungen an der Firewall.
```
sudo firewall-cmd --list-all
```
Die Ausgabe zeigt ports: 5808/tcp verfügbar an.

SSH-Portweiterleitung verwenden

Öffnen Sie ein Terminal, und stellen Sie eine SSH-Verbindung zur Oracle Cloud Developer-Instanz her.

Mit der Option -L wird die lokale Weiterleitung aktiviert. Dadurch wird ein lokaler Port geöffnet, um über einen SSH-Tunnel eine Verbindung zur Remote-Demo-Webanwendung herzustellen.
```
ssh -L 5808:localhost:5808 -i <SSH_KEY> opc@<IP_ADDRESS_OF_ORACLE_CLOUD_DEVELOPER_INSTANCE>
```

Containerimage für eine Webanwendung erstellen und lokal ausführen

Klonen Sie das Git-Repository der Demoanwendung.

Für dieses Tutorial stellen Sie RasDash bereit, eine Node.js-basierte Webanwendung zur Serverüberwachung.
```
git clone https://github.com/sykeben/RasDash.git
```
Wechseln Sie in das Quellcodeverzeichnis.
```
cd  ~/RasDash
```

Erstellen Sie eine Containerdatei, um die Webanwendung zu erstellen und zu bedienen.

cat << EOF > Containerfile
FROM ghcr.io/oracle/oraclelinux8-nodejs:14
COPY . /app
WORKDIR /app
RUN npm install && \
  npm test
CMD ["/usr/bin/node", "app.js", "service"]
EOF

Erstellen und führen Sie das Image auf der lokalen Instanz aus.

Erstellen Sie das Containerimage lokal mit podman, und taggen Sie das Image mit der Version der Anwendung und der Architektur der Plattform. Diese Informationen sind später hilfreich, wenn Sie jedes Plattformimage an Oracle Cloud Infrastructure Registry (OCIR) übertragen und ein Manifest der beiden Plattformimages erstellen.
```
sudo podman build --format docker --tag rasdash:0.3.4-arm64 .
```
Die letzte Zeile ist für die Anwendungserstellung eindeutig.
Führen Sie einen Container mit dem Bild aus.
```
sudo podman run --rm --init -detach --name rasdash --publish 5808:5808 localhost/rasdash:0.3.4-arm64
```
Der Digest, den Podman zurückgibt, ist für jede Containerinstanz eindeutig.
Zeigen Sie den laufenden Container an.
```
sudo podman ps
```
Die Ausgabe zeigt den Container als Up an und wird ausgeführt.
Zeigen Sie die Containerlogs an.
```
sudo podman logs rasdash
```
In der Ausgabe wird [STATE] Server started angezeigt.
Webanwendung anzeigen.

Öffnen Sie einen Browser auf dem lokalen Rechner, und navigieren Sie zu http://localhost:5808. Wenn Sie die Ingress- und Firewallregeln erstellt haben, können Sie die öffentliche IP-Adresse der Oracle Cloud Developer-Instanz anstelle von localhost verwenden.

Hinweis: Die CPU-Temperaturmetrik zeigt -1 an, da virtuelle Instanzen in OCI nicht auf physische Hardwaredaten zugreifen können.
Stoppen Sie den laufenden Container.
```
sudo podman stop rasdash
```

Kennwortloses SSH zwischen Instanzen konfigurieren

Podman kommuniziert aus Sicherheitsgründen mit SSH zwischen Instanzen. Für eine nahtlosere Erfahrung erstellen Sie ein Public/Private-Key-Paar auf Ihrer Cloud Developer-Instanz und kopieren dieses auf den Podman Remote-Server, damit Sie SSH von der Entwicklerinstanz aus verwenden können, ohne zur Eingabe eines Kennworts aufgefordert zu werden.

Generieren Sie ein Public/Private-Key-Paar in der Oracle Cloud Developer-Instanz.
```
ssh-keygen -b 4096 -f ~/.ssh/id_rsa -q -N ""
```
Kopieren Sie den Inhalt der Public-Key-Datei.
```
cat ~/.ssh/id_rsa.pub
```
Wählen Sie die Ausgabe aus dem Befehl cat, und kopieren Sie sie.
Wechseln Sie zur Podman-Serverinstanz.
Öffnen Sie die Datei in vi.
```
vi ~/.ssh/authorized_keys
```
Fügen Sie den Inhalt des Public Keys in die Datei mit den autorisierten Schlüsseln ein.

Speichern und schließen Sie die Datei.
Stellen Sie sicher, dass Sie die richtigen Dateisystemberechtigungen auf das SSH-Verzeichnis und die Dateien anwenden.
```
chmod 700 ~/.ssh && chmod 600 ~/.ssh/authorized_keys
```
Wechseln Sie zur Cloud Developer-Instanz.
Testen Sie, ob Sie als Benutzer opc eine SSH-Verbindung zum Podman-Server herstellen können, ohne dass ein Kennwort erforderlich ist.
Hinweis: Wenn Probleme auftreten, lesen Sie die folgende Dokumentation:
```
ssh opc@<IP_ADDRESS_OF_PODMAN_SERVER_INSTANCE>
```
Nachdem Sie geprüft haben, dass Sie eine Verbindung herstellen können, ohne ein Kennwort zu benötigen, stellen Sie sicher, dass Sie die SSH-Session zwischen der Oracle Cloud Developer-Instanz und dem Podman-Server exit.
Wechseln Sie zur Podman-Serverinstanz.

Ersetzen Sie die Datei mit autorisierten Schlüsseln des Root-Benutzers.

cat /home/opc/.ssh/authorized_keys | sudo tee /root/.ssh/authorized_keys

Wechseln Sie zur Cloud Developer-Instanz.
Testen Sie, ob Sie SSH mit dem Benutzer opc in der Cloud Developer-Instanz an den Benutzer root auf dem Podman-Server senden können.
```
ssh root@<IP_ADDRESS_OF_PODMAN_SERVER_INSTANCE>
```
Sie können die Session nach dem erfolgreichen Testen der SSH-Verbindung zum Podman-Server als Root-Benutzer exit.

Systemverbindung zum Podman-Server erstellen

Erstellen Sie eine Podman-Systemverbindung zwischen der Oracle Cloud Developer-Instanz und dem auf Ihrem Podman-Server ausgeführten Podman-Service.
```
sudo podman system connection add --identity ~/.ssh/id_rsa amd64 ssh://root@<IP_ADDRESS_OF_PODMAN_SERVER_INSTANCE>/run/podman/podman.sock
```
Stellen Sie im obigen Befehl sicher, dass Sie <IP_ADDRESS_OF_PODMAN_SERVER_INSTANCE> durch die IP-Adresse oder den Hostnamen Ihres Podman-Servers ersetzen.
Stellen Sie sicher, dass Sie die Verbindung erfolgreich hinzugefügt haben.
```
sudo podman system connection list
```
In der Ausgabe wird die Verbindung amd64 angezeigt, wobei der Wert Default auf true gesetzt ist. Podman verwendet diese Verbindung, wenn auf dem System mehrere Verbindungen konfiguriert sind.

Image auf dem Remote-Podman-Server erstellen

Sie sollten jetzt podman --remote verwenden können, um Befehle von der Oracle Cloud Developer-Instanz an die Remote-Podman-Serverinstanz zu senden.

Testen Sie, indem Sie die Details des Podman-Servers abrufen.
```
sudo podman --remote info
```
Die Architektur sollte als arm64 gemeldet werden.
Erstellen Sie das Remote-Image.

Podman kopiert den gesamten Kontext automatisch in die Remoteinstanz.
```
cd ~/RasDash
sudo podman --remote build --format docker --tag rasdash:0.3.4-amd64 .
```
Prüfen Sie, ob das Image auf dem Remote-Podman-Server vorhanden ist.

HINWEIS: Podman kopiert das von ihm erstellte Image nicht wieder auf den Clientrechner. Daher wird das Image nicht aufgeführt, wenn Sie sudo podman images ausführen. Es ist jedoch auf dem Remote-Rechner verfügbar.
```
sudo podman --remote images
```
Beispielausgabe:
```
REPOSITORY                          TAG          IMAGE ID      CREATED        SIZE
localhost/rasdash                   0.3.4-amd64  3a1b9755ebdd  8 seconds ago  439 MB
...
```
Lokale Imagearchitektur prüfen

Die letzte Methode zur Validierung, ob jedes Image für (und auf) eine bestimmte Plattform und Architektur erstellt wurde, verwendet jq, um den Wert des Feldes Architecture im Manifest jedes Images zu extrahieren.
```
sudo podman inspect rasdash:0.3.4-arm64 | jq -r '.[] | .Architecture'
```
Das lokale Image meldet seine Architektur als arm64.

Prüfen Sie das Remote-Abbild.

sudo podman --remote inspect rasdash:0.3.4-amd64 | jq -r '.[] | .Architecture'

Das Remoteimage wird als amd64 gemeldet.

Container Registry Repository erstellen

Navigieren Sie in der Oracle Cloud Infrastructure-Konsole zum Abschnitt Container Registry, und erstellen Sie ein Repository zum Speichern Ihrer plattformübergreifenden Anwendung.

Weitere Informationen finden Sie unter Repository erstellen in der Oracle Cloud Infrastructure-Dokumentation.

Erstellen Sie das private demo/rasdash-Repository.
Prüfen Sie die Details des neuen Repositorys.

Zugangsdaten für das Container Registry-Repository erfassen

Die folgende Tabelle enthält Beispielwerte, die in den nachfolgenden Schritten in diesem Tutorial verwendet werden. Das Beispiel iad ist der Regionsschlüssel für die Region "US East (Ashburn)". Wenn Ihre Region Germany Central (Frankfurt) ist, lautet der Regionsschlüssel fra. In der Dokumentation zu Regionen und Availability-Domains finden Sie eine vollständige Tabelle, in der die verfügbaren Regionsschlüssel aufgeführt werden.

Registry-Daten	Tutorialplatzhalter	Hinweise:
REGISTRY_NAMESPACE	`gse00015915`	Wird im Repository-Infobereich als "Namespace" angezeigt
REPOSITORY_NAME	`demo/rasdash`	Unter dem Compartment-Namen angezeigt
OCIR_INSTANCE	`iad.ocir.io`	Verwenden Sie `<region>.ocir.io`

Siehe Images mit der Docker-CLI per Pushen, falls erforderlich. In diesem Verfahren wird der Anmeldeprozess beschrieben, der zum Übertragen von Images mit der CLI in die Container Registry erforderlich ist.

Hol dir deinen Benutzernamen.

Sie benötigen einen Benutzernamen und ein Authentifizierungstoken, um sich bei der Containerregistrierung anzumelden. Um den Benutzernamen abzurufen, öffnen Sie in der oberen rechten Ecke der Oracle Cloud Infrastructure-Konsole das Menü Profil (Benutzermenüsymbol), und klicken Sie auf Mein Profil, um die Details anzuzeigen.

Kopieren Sie den Benutzernamen, und speichern Sie ihn, einschließlich der in der Konsole angezeigten tenancy-namespace.
Generieren Sie ein Authentifizierungstoken.

Scrollen Sie auf der Seite Mein Profil in der Konsole nach unten, und wählen Sie unter Ressourcen die Option Authentifizierungstoken aus.

Wählen Sie die Schaltfläche Token generieren, und geben Sie eine Beschreibung demo für das neue Token an.

Nachdem Sie das Token generiert haben, müssen Sie es kopieren und speichern.

Die folgende Tabelle enthält Beispielwerte, die in den nachfolgenden Schritten in diesem Tutorial verwendet werden.

Benutzername	Tutorialplatzhalter
REGISTRY_NAMESPACE	`gse00015915`
USERNAME	`luna.user@e1ab5742-7e30-463a-9017-0b48fa54197e`
TOKEN	`]y#W_iS9GKC}4l1Gq9Fn`
OCIR_INSTANCE	`iad.ocir.io`

Erstellen Sie Umgebungsvariablen zur Verwendung im Befehl podman login.

Erstellen Sie die Umgebungsvariablen USER und TOKEN mit Ihrem Benutzernamen und Token. Stellen Sie sicher, dass Sie die <REGISTRY_NAMESPACE> als Teil des Benutzernamens aufnehmen.

export OCIR_INSTANCE="iad.ocir.io"
export OCIR_NAMESPACE="gse00015915"
export OCI_USERNAME="luna.user@e1ab5742-7e30-463a-9017-0b48fa54197e"
export OCIR_USERNAME="$OCIR_NAMESPACE/$OCI_USERNAME"
export OCI_USER_TOKEN="]y#W_iS9GKC}4l1Gq9Fn"

Melden Sie sich bei der Containerregistrierung an.
```
sudo -E podman login -u $OCIR_USERNAME -p $OCIR_USER_TOKEN $OCIR_INSTANCE
```
Die Remoteinstanz erbt automatisch die Authentifizierungszugangsdaten von der Clientinstanz.

Plattformimages übertragen

In diesem Beispiel lauten die endgültigen Repository-URIs mit plattformspezifischen Tags wie folgt:

docker://iad.ocir.io/gse00015915/demo/rasdash:0.3.4-arm64
docker://iad.ocir.io/gse00015915/demo/rasdash:0.3.4-amd64

Podman kann lokale Images an Remote-Registrys übertragen, ohne dass das Image vorher getaggt werden muss.

Übertragen Sie das lokale rasdash/0.3.4-arm64-Image.

sudo -E podman push rasdash:0.3.4-arm64 docker://$OCIR_INSTANCE/$OCIR_NAMESPACE/demo/rasdash:0.3.4-arm64

Senden Sie das Remote-Abbild rasdash:0.3.4-amd64.

sudo -E podman --remote push rasdash:0.3.4-amd64 docker://$OCIR_INSTANCE/$OCIR_NAMESPACE/demo/rasdash:0.3.4-amd64

Prüfen Sie die Container Registry-Konsole.

Hinweis: Wenn Sie ein Remoteimage per Push übertragen, wird keine lokale Ausgabe generiert. Prüfen Sie in der Container Registry-Konsole das Tag rasdash:0.3.4-amd64, um zu prüfen, ob Sie das Image erfolgreich übertragen haben.

In der Container Registry-Konsole sollten zwei Images angezeigt werden.

Das Image 0.3.4-amd64:

Das Image 0.3.4-arm64:

Manifestliste erstellen und in Container Registry übertragen

Jetzt, da Sie zwei Plattformimages haben, ist es an der Zeit, eine Manifestliste zu erstellen, damit Container-Laufzeiten das geeignete Image für ihre Plattform auswählen können. Dies ist eine Kombination aus Betriebssystem und Architektur.

Da die meisten Containerimages Linux-basiert sind, bezeichnen Benutzer in der Regel ein plattformübergreifendes Image als Multi-Arch-Image. Es ist jedoch auch möglich, Images, die unter Windows, macOS und Linux ausgeführt werden können, in einem einzigen Manifest zu kombinieren.

Erstellen Sie das Manifest und füllen Sie es auf.

Erstellen Sie eine lokale Manifestliste auf der Cloud Developer-Instanz mit nur der App-Version im Tag.
```
sudo podman manifest create rasdash:0.3.4
```
Wie zuvor ist die Prüfsummenausgabe für das von Ihnen erstellte Manifest eindeutig und stimmt nicht mit dem oben genannten überein.
Prüfen Sie die Manifestliste, um aufzudecken, welche mediaType verwendet wird und welche Member-Images sie verwenden.
```
sudo podman manifest inspect rasdash:0.3.4
```

Fügen Sie die beiden plattformspezifischen Images zur Liste hinzu.

sudo -E podman manifest add rasdash:0.3.4 docker://$OCIR_INSTANCE/$OCIR_NAMESPACE/demo/rasdash:0.3.4-arm64

sudo -E podman manifest add rasdash:0.3.4 docker://$OCIR_INSTANCE/$OCIR_NAMESPACE/demo/rasdash:0.3.4-amd64

Prüfen Sie die Manifestliste.
```
sudo podman manifest inspect rasdash:0.3.4
```
Die Ausgabe ist nach dem Hinzufügen der Bilder interessanter.

Um maximale Kompatibilität zu gewährleisten, haben Sie jedem Build-Befehl den Parameter --format docker hinzugefügt. Dieser weist Podman an, das Image mit der Spezifikation Docker-Imagemanifest V2, Schema 2 (v2s2) anstelle der Open Container Initiative Image Manifest Specification zu erstellen, die Podman standardmäßig verwendet.

Da die Manifeste die v2s2-Spezifikation verwenden, verwendet Podman die zugehörige v2s2 Manifestliste-Spezifikation anstelle der Open Container Initiative Image Index Specification.

Die Standard-Containerlaufzeiten, die sowohl von cloud-basierten verwalteten Kubernetes-Services verwendet werden, einschließlich Oracle Engine for Kubernetes (OKE) als auch von On-Premise-selbst gehosteten Kubernetes-Distributionen, sind mit beiden Spezifikationen kompatibel.
Übertragen Sie die Manifestliste in die Container Registry.

Nachdem Sie die Manifestliste erstellt haben, können Sie sie in dasselbe Container Registry-Repository übertragen, in dem die plattformspezifischen Images gespeichert sind.
```
sudo -E podman manifest push --all rasdash:0.3.4 docker://$OCIR_INSTANCE/$OCIR_NAMESPACE/demo/rasdash:0.3.4
```
Diese Aktion ist eine schnelle Operation, da Sie die plattformspezifischen Images zuvor übertragen haben. Die Container Registry verknüpft nur die Manifestliste mit den vorhandenen Images.
Erstellen Sie das Image, und führen Sie es lokal aus.

Sie können jetzt eine Instanz des Images lokal und remote mit dem Manifestlisten-Tag anstelle des plattformspezifischen Tags ausführen.
```
sudo -E podman run --rm --detach --init --publish 5808:5808 $OCIR_INSTANCE/$OCIR_NAMESPACE/demo/rasdash:0.3.4
```

Erstellen Sie das Image, und führen Sie es remote aus.

sudo -E podman --remote run --rm --detach --init --publish 5808:5808 $OCIR_INSTANCE/$OCIR_NAMESPACE/demo/rasdash:0.3.4

Bilder mit einem Browser testen

Angenommen, Sie haben die erforderlichen Ingress-Regeln und Firewall-Regeln für die Instanzen erstellt. In diesem Fall können Sie den Browser öffnen und zu http://<PUBLIC_IP_ADDRESS_OF_ORACLE_CLOUD_DEVELOPER_INSTANCE>:5808 und http://<PUBLIC_IP_ADDRESS_OF_PODMAN_SERVER_INSTANCE>:5808 navigieren, um die RasDash-Webanwendung zu öffnen, die auf jeder Instanz ausgeführt wird.

Andernfalls können Sie die SSH-Portweiterleitung wie zuvor verwenden, indem Sie zwei Tunnel auf Ihrem lokalen Rechner erstellen.

Öffnen Sie einen SSH-Tunnel zur Oracle Cloud Developer-Instanz.
```
ssh -L 5808:localhost:5808 -i <SSH_KEY> opc@<IP_ADDRESS_OF_ORACLE_CLOUD_DEVELOPER_INSTANCE>
```
Öffnen Sie einen Browser auf dem lokalen Rechner, und navigieren Sie zu http://localhost:5808, um die arm64-basierte Webanwendung in der Cloud Development-Instanz anzuzeigen.
Beenden Sie die SSH-Tunnelsession.
Öffnen Sie einen SSH-Tunnel zur Podman-Serverinstanz.
```
ssh -L 5808:localhost:5808 -i <SSH_KEY> opc@<IP_ADDRESS_OF_PODMAN_SERVER_INSTANCE>
```
Aktualisieren Sie den Browser auf dem lokalen Rechner, der auf http://localhost:5808 verweist, um die amd64-basierte Webanwendung auf der Podman-Serverinstanz anzuzeigen.

Nächste Schritte

Nachdem Sie dieses Tutorial abgeschlossen haben, sollten Sie nun wissen, wie Sie Images erstellen, die Sie aus privaten und öffentlichen OCIR-Repositorys bereitstellen können. Sie können diese Images an verschiedenen Standorten verwenden, wie Oracle Engine for Kubernetes (OKE) oder Oracle Cloud Native Environment. Wenn Sie Ihre Images auf Hosts außerhalb von Oracle Cloud Infrastructure bereitstellen, einschließlich Podman Desktop für Mac oder Windows, müssen Sie sicherstellen, dass das Repository öffentlich ist.

Weitere Lernressourcen

Sehen Sie sich weitere Übungen zu docs.oracle.com/learn an, oder greifen Sie auf weitere kostenlose Lerninhalte im Oracle Learning YouTube-Kanal zu. Besuchen Sie außerdem education.oracle.com/learning-explorer, um ein Oracle Learning Explorer zu werden.

Die Produktdokumentation finden Sie im Oracle Help Center.

Titel und Copyright-Informationen

Build Multi-Platform Container Images Using Podman on Oracle Linux

F50005-04

Oracle und/oder verbundene Unternehmen.