Crea immagini container multipiattaforma con Podman su Oracle Linux

Introduzione

Questa demo mostra la creazione di un'immagine container multipiattaforma con Podman su Oracle Linux.

Obiettivi

In questo tutorial, imparerai come:

Configurare Podman per la connettività remota
Connettersi a un'istanza Podman remota
Crea immagini specifiche della piattaforma da un singolo Containerfile
Esegui il push delle immagini specifiche della piattaforma in Oracle Cloud Infrastructure Registry (OCIR)
Creare un elenco di file manifesto che includa entrambe le immagini specifiche della piattaforma
Invia l'elenco di manifesti a OCIR
Ispezionare l'elenco di file manifesti ospitati su OCIR per visualizzare le piattaforme disponibili
Estrarre ed eseguire l'immagine

Prerequisiti

Accesso a una tenancy Oracle Cloud Infrastructure (OCI)
Un'istanza di Oracle Linux x86_64
Un'istanza di Oracle Cloud Developer aarch_64
Accesso a Oracle Cloud Infrastructure Registry

Distribuire un server Podman

Crea un'istanza di computazione Oracle Linux.

È possibile utilizzare l'immagine e la forma predefinite, purché la forma utilizzi un'architettura x86_64. Selezionare o creare una subnet pubblica e assegnare un indirizzo IPv4.

Questo passo supporta l'utilizzo delle forme Micro disponibili nel livello Sempre gratis.
Una volta eseguita l'istanza, eseguire il login all'istanza.
```
ssh -i <SSH_KEY> opc@<IP_ADDRESS_OF_PODMAN_SERVER_INSTANCE>
```
dove:
- <SSH_KEY> è la parte privata della chiave SSH utilizzata durante il provisioning dell'istanza di computazione. Esempio: ~/.ssh/id_rsa
- <IP_ADDRESS_OF_PODMAN_SERVER_INSTANCE> è l'indirizzo IP pubblico dell'istanza di computazione.

Installazione e configurazione di Podman per l'accesso remoto

È possibile eseguire questi comandi come account utente opc predefinito nell'istanza di computazione o in qualsiasi utente con accesso sudo.

Aggiorna il sistema con tutte le correzioni di sicurezza e gli errori più recenti.
```
sudo dnf -y update
```
Installare i pacchetti o i moduli Podman.

Oracle Linux 8:
```
sudo dnf module install -y container-tools:ol8
```
Oracle Linux 9 e Oracle Linux 10:
```
sudo dnf install -y container-tools
```
Il modulo o il pacchetto container-tools installa podman e altri strumenti container, tra cui skopeo e buildah. Un pacchetto essenziale è container-selinux, che consente di eseguire podman come utente non root su un sistema abilitato per SELinux, abilitato per impostazione predefinita da Oracle Linux.
Abilitare il socket Podman.

systemd ascolterà su quel socket e avvierà un'istanza di Podman ogni volta che un client remoto lo attiva. Quando la connessione viene chiusa, systemd arresterà l'istanza di Podman.

Nota: è possibile configurare l'accesso Podman remoto in modalità rootless, ma questo non rientra nell'ambito di questa esercitazione.
```
sudo systemctl enable --now podman.socket
```
Verificare il percorso del socket.
```
sudo systemctl status podman.socket
```
L'output mostra l'ascolto del socket e la sua posizione è /run/podman/podman.sock.

Questo è tutto, ma resta connesso all'istanza del server Podman per eseguire la configurazione SSH senza password più avanti in questa esercitazione.

Distribuire un'istanza di Oracle Cloud Developer

Oracle Ampere A1 Compute è una piattaforma ad alte prestazioni che combina i processori Oracle Cloud Infrastructure (OCI) e Ampere Altra Arm. Offre prestazioni deterministiche, sicurezza comprovata e un ampio ecosistema di sviluppatori che include strumenti e ambienti più diffusi (OS, Kubernetes - OKE, SDK e CLI).

OCI elenca l'immagine Oracle Cloud Developer Image come piattaforma con tutti i più diffusi strumenti di sviluppo installati, tra cui Git, Node.js, Java e GraalVM.

Creare un'istanza di computazione Oracle Cloud Developer.

Selezionare l'immagine Oracle Cloud Developer e una forma Ampere. Selezionare la stessa subnet pubblica dell'istanza del server Podman e assegnare un indirizzo IPv4.
Decidere di utilizzare le regole di entrata o l'inoltro della porta SSH.

Puoi accedere all'applicazione Web demo che creeremo in due modi. Mentre è possibile abilitare entrambi, è necessario solo scegliere l'uno o l'altro.

(Facoltativo) Creare una regola di entrata

L'utilizzo di una regola di entrata è un processo in due fasi. Questa opzione apre l'accesso alla subnet da Internet e continua a concedere l'accesso all'istanza sulla porta specificata anche dopo un riavvio. È necessario creare la regola all'interno di OCI, quindi aprire la porta all'interno del firewalld sull'istanza di Oracle Linux.

Aggiungere una regola di entrata alla subnet pubblica.

La regola deve consentire il traffico in entrata sulla porta 5808/tcp da 0.0.0.0/0. La regola ha effetto immediatamente dopo la creazione.
Aprire un nuovo terminale e connettersi all'istanza di Oracle Cloud Developer tramite SSH.
```
ssh -i <SSH_KEY> opc@<IP_ADDRESS_OF_ORACLE_CLOUD_DEVELOPER_INSTANCE>
```

Aggiungere l'accesso all'applicazione Web demo.

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

Confermare le modifiche al firewall.
```
sudo firewall-cmd --list-all
```
L'output mostra ports: 5808/tcp disponibile.

Usa inoltro porta SSH

Aprire un terminale e connettersi tramite SSH all'istanza di Oracle Cloud Developer.

L'opzione -L abilita l'inoltro locale, che apre una porta locale per connettersi tramite un tunnel SSH all'applicazione Web demo remota.
```
ssh -L 5808:localhost:5808 -i <SSH_KEY> opc@<IP_ADDRESS_OF_ORACLE_CLOUD_DEVELOPER_INSTANCE>
```

Creare un'immagine contenitore per un'applicazione Web ed eseguirla localmente

Duplicare il repository Git dell'applicazione demo.

Per questa esercitazione verrà distribuita RasDash, un'applicazione Web di monitoraggio del server basata su Node.js.
```
git clone https://github.com/sykeben/RasDash.git
```
Passare alla directory del codice sorgente.
```
cd  ~/RasDash
```

Creare un Containerfile per creare e gestire l'applicazione Web.

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

Creare ed eseguire l'immagine sull'istanza locale.

Creare l'immagine del contenitore localmente utilizzando podman e contrassegnare l'immagine con la versione dell'applicazione e l'architettura della piattaforma. Queste informazioni saranno utili in un secondo momento quando esegui il push di ogni immagine della piattaforma in Oracle Cloud Infrastructure Registry (OCIR) e quando crei un file manifesto delle due immagini della piattaforma.
```
sudo podman build --format docker --tag rasdash:0.3.4-arm64 .
```
La riga finale sarà univoca per la build dell'applicazione.
Eseguire un contenitore utilizzando l'immagine.
```
sudo podman run --rm --init -detach --name rasdash --publish 5808:5808 localhost/rasdash:0.3.4-arm64
```
Il digest restituito da Podman è univoco per ogni istanza del contenitore.
Visualizzare il contenitore in esecuzione.
```
sudo podman ps
```
L'output visualizza il contenitore come Up e in esecuzione.
Visualizzare i log del contenitore.
```
sudo podman logs rasdash
```
L'output mostra [STATE] Server started.
Visualizzare l'applicazione Web.

Aprire un browser sul computer locale e andare a http://localhost:5808. Se hai creato le regole di entrata e firewall, puoi utilizzare l'indirizzo IP pubblico dell'istanza di Oracle Cloud Developer anziché localhost.

Nota: la metrica della temperatura della CPU visualizzerà -1 poiché le istanze virtuali in OCI non possono accedere ai dati hardware fisici.
Arrestare il contenitore in esecuzione.
```
sudo podman stop rasdash
```

Configurare SSH senza password tra le istanze

Podman comunica utilizzando SSH tra le istanze per motivi di sicurezza. Per un'esperienza più fluida, crea una coppia di chiavi pubblica/privata nell'istanza di Cloud Developer e copiala nel server remoto Podman in modo da poter eseguire l'SSH dall'istanza di sviluppatore senza che venga richiesta una password.

Genera una coppia di chiavi pubblica/privata nell'istanza di Oracle Cloud Developer.
```
ssh-keygen -b 4096 -f ~/.ssh/id_rsa -q -N ""
```
Copiare il contenuto del file della chiave pubblica.
```
cat ~/.ssh/id_rsa.pub
```
Selezionare l'output del comando cat e copiarlo.
Passare all'istanza del server Podman.
Aprire il file in vi.
```
vi ~/.ssh/authorized_keys
```
Incollare il contenuto della chiave pubblica nel file delle chiavi autorizzate.

Salvare e chiudere il file.
Assicurarsi di applicare le autorizzazioni corrette del file system alla directory e ai file SSH.
```
chmod 700 ~/.ssh && chmod 600 ~/.ssh/authorized_keys
```
Passare all'istanza di Cloud Developer.
Verificare se è possibile eseguire l'accesso SSH al server Podman come utente opc senza richiedere una password.
Nota: in caso di problemi, consultare la documentazione riportata di seguito.
```
ssh opc@<IP_ADDRESS_OF_PODMAN_SERVER_INSTANCE>
```
Dopo aver verificato che è possibile connettersi senza richiedere una password, assicurarsi di exit la sessione SSH tra l'istanza di Oracle Cloud Developer e il server Podman.
Passare all'istanza del server Podman.

Sostituire il file delle chiavi autorizzate dell'utente root.

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

Passare all'istanza di Cloud Developer.
Eseguire il test se è possibile eseguire il test SSH con l'utente opc nell'istanza di Cloud Developer per l'utente root nel server Podman.
```
ssh root@<IP_ADDRESS_OF_PODMAN_SERVER_INSTANCE>
```
È possibile eseguire il exit della sessione dopo aver verificato correttamente la connessione SSH al server Podman come utente root.

Creare una connessione di sistema al server Podman

Creare una connessione di sistema Podman tra l'istanza di Oracle Cloud Developer e il servizio Podman in esecuzione sul server Podman.
```
sudo podman system connection add --identity ~/.ssh/id_rsa amd64 ssh://root@<IP_ADDRESS_OF_PODMAN_SERVER_INSTANCE>/run/podman/podman.sock
```
Nel comando precedente, assicurarsi di sostituire <IP_ADDRESS_OF_PODMAN_SERVER_INSTANCE> con l'indirizzo IP o il nome host del server Podman.
Verificare che la connessione sia stata aggiunta correttamente.
```
sudo podman system connection list
```
L'output visualizza la connessione amd64 con il valore Default impostato su true. Podman utilizza questa connessione se nel sistema sono configurate più connessioni.

Creare un'immagine sul server Podman remoto

Ora dovrebbe essere possibile utilizzare podman --remote per inviare i comandi dall'istanza di Oracle Cloud Developer all'istanza remota del server Podman.

Eseguire il test ottenendo i dettagli del server Podman.
```
sudo podman --remote info
```
Il report dell'architettura deve essere arm64.

Creare l'immagine remota.

Podman copierà automaticamente l'intero contesto nell'istanza remota.

cd ~/RasDash
sudo podman --remote build --format docker --tag rasdash:0.3.4-amd64 .

Verificare che l'immagine esista sul server Podman remoto.

NOTA: Podman non copia l'immagine creata di nuovo nel computer client, pertanto l'immagine non verrà elencata se si esegue sudo podman images. Tuttavia, è disponibile sulla macchina remota.
```
sudo podman --remote images
```
Output di esempio:
```
REPOSITORY                          TAG          IMAGE ID      CREATED        SIZE
localhost/rasdash                   0.3.4-amd64  3a1b9755ebdd  8 seconds ago  439 MB
...
```
Verificare l'architettura dell'immagine locale.

Il metodo finale di validazione che ogni immagine è stata costruita per (e su) una specifica piattaforma e architettura utilizza jq per estrarre il valore del campo Architecture nel manifesto di ogni immagine.
```
sudo podman inspect rasdash:0.3.4-arm64 | jq -r '.[] | .Architecture'
```
L'immagine locale riporta la relativa architettura come arm64.

Controllare l'immagine remota.

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

L'immagine remota viene indicata come amd64.

Creare un repository di Container Registry

Nella console di Oracle Cloud Infrastructure, vai alla sezione Container Registry e crea un repository per memorizzare l'applicazione multipiattaforma.

Per ulteriori dettagli, vedere Creazione di un repository nella documentazione di Oracle Cloud Infrastructure.

Creare il repository demo/rasdash privato.
Rivedere i dettagli del nuovo repository.

Raccogliere le credenziali del repository del registro contenitore

Nella tabella seguente sono riportati i valori di esempio utilizzati nei passi successivi di questa esercitazione. L'esempio iad è la chiave area per l'area orientale degli Stati Uniti (Ashburn). Se l'area è Germania centrale (Francoforte), la chiave area è fra. Fare riferimento alla documentazione Aree e domini di disponibilità per una tabella completa che elenca le chiavi di area disponibili.

Dati registro	Segnaposto esercitazione	Note
REGISTRY_NAMESPACE	`gse00015915`	Visualizzato nel pannello delle informazioni del repository come "Spazio di nomi"
REPOSITORY_NAME	`demo/rasdash`	Visualizzato sotto il nome del compartimento
OCIR_INSTANCE	`iad.ocir.io`	Usa `<region>.ocir.io`

Se necessario, vedere Push delle immagini mediante l'interfaccia CLI Docker. Questa procedura descrive il processo di login necessario per eseguire il PUSH delle immagini nel Container Registry utilizzando l'interfaccia CLI.

Ottieni il tuo nome utente.

È necessario un nome utente e un token di autenticazione per eseguire il login al registro contenitore. Per ottenere il nome utente, nell'angolo in alto a destra della console di Oracle Cloud Infrastructure, aprire il menu Profilo (icona del menu Utente), quindi fare clic su Profilo personale per visualizzare i dettagli.

Copiare e salvare il nome utente, incluso il file tenancy-namespace visualizzato nella console.
Generare un token di autenticazione.

Scorrere la pagina Profilo personale nella console e selezionare Token di autenticazione in Risorse.

Selezionare il pulsante Genera token e fornire una descrizione di demo per il nuovo token.

Dopo aver generato il token, assicurarsi di copiarlo e salvarlo.

Nella tabella seguente sono riportati i valori di esempio utilizzati nei passi successivi di questa esercitazione.

Nome utente	Segnaposto esercitazione
REGISTRY_NAMESPACE	`gse00015915`
NOME UTENTE	`luna.user@e1ab5742-7e30-463a-9017-0b48fa54197e`
TOKEN	`]y#W_iS9GKC}4l1Gq9Fn`
OCIR_INSTANCE	`iad.ocir.io`

Creare le variabili di ambiente da utilizzare nel comando podman login.

Creare le variabili di ambiente USER e TOKEN utilizzando il nome utente e il token. Assicurarsi di includere <REGISTRY_NAMESPACE> come parte del nome utente.

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"

Eseguire il login al registro contenitore.
```
sudo -E podman login -u $OCIR_USERNAME -p $OCIR_USER_TOKEN $OCIR_INSTANCE
```
L'istanza remota erediterà automaticamente le credenziali di autenticazione dall'istanza client.

Push delle immagini della piattaforma

In questo esempio, gli URI del repository finale con tag specifiche della piattaforma sono:

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

Podman può inviare immagini locali a registri remoti senza che l'immagine debba essere contrassegnata in anticipo.

Premere l'immagine rasdash/0.3.4-arm64 locale.

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

Eseguire il push dell'immagine rasdash:0.3.4-amd64 remota.

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

Controllare la console Container Registry.

Nota: se si spinge un'immagine remota, l'output locale non viene generato. Esaminare la console Container Registry per la tag rasdash:0.3.4-amd64 per verificare se è stato eseguito correttamente il push dell'immagine.

Nella console Container Registry dovrebbero essere visualizzate due immagini.

L'immagine 0.3.4-amd64:

L'immagine 0.3.4-arm64:

Creare e inviare un elenco di file manifesto al registro dei contenitori

Ora che hai due immagini della piattaforma, è il momento di creare una lista di file manifesto per consentire ai runtime dei container di selezionare l'immagine appropriata per la loro piattaforma, che è una combinazione del sistema operativo e dell'architettura.

Poiché la maggior parte delle immagini dei container è basata su Linux, gli utenti in genere fanno riferimento a un'immagine multipiattaforma come un'immagine multi-arch. Tuttavia, è anche possibile combinare le immagini che possono essere eseguite su Windows, macOS e Linux in un unico file manifesto.

Creare e inserire dati nel manifesto.

Creare un elenco di file manifesto locale nell'istanza di sviluppo cloud con solo la versione dell'applicazione nella tag.
```
sudo podman manifest create rasdash:0.3.4
```
Come in precedenza, l'output del checksum è univoco nel file manifesto creato e non corrisponderà a quello indicato sopra.
Ispezionare l'elenco di file manifesto per visualizzare gli elementi utilizzati da mediaType e le relative immagini membro.
```
sudo podman manifest inspect rasdash:0.3.4
```

Aggiungere all'elenco le due immagini specifiche della piattaforma.

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

Analizzare l'elenco dei file manifesti.
```
sudo podman manifest inspect rasdash:0.3.4
```
L'output è più interessante dopo aver aggiunto le immagini.

Per ottenere la massima compatibilità, è stato aggiunto il parametro --format docker a ciascun comando di creazione, che indica a Podman di creare l'immagine utilizzando la specifica Docker Image Manifest V2, Schema 2 (v2s2) anziché la specifica Open Container Initiative Image Manifest, che Podman utilizzerà per impostazione predefinita.

Poiché i file manifesto utilizzano la specifica v2s2, Podman utilizza la specifica v2s2 Manifest List associata anziché la specifica Open Container Initiative Image Index.

I runtime dei container predefiniti utilizzati da entrambi i servizi Kubernetes gestiti basati su cloud, tra cui Oracle Engine for Kubernetes (OKE) e le distribuzioni Kubernetes self-hosted on-premise, sono compatibili con entrambe le specifiche.
Eseguire il push dell'elenco di file manifesto nel registro contenitori.

Dopo aver creato l'elenco di file manifesto, è possibile eseguirne il push nello stesso repository del registro dei contenitori in cui sono memorizzate le immagini specifiche della piattaforma.
```
sudo -E podman manifest push --all rasdash:0.3.4 docker://$OCIR_INSTANCE/$OCIR_NAMESPACE/demo/rasdash:0.3.4
```
Questa azione è un'operazione rapida perché è stato eseguito il push delle immagini specifiche della piattaforma in precedenza. Container Registry collega l'elenco di manifesti alle immagini esistenti.
Creare ed eseguire l'immagine localmente.

È ora possibile eseguire un'istanza dell'immagine localmente e in remoto utilizzando il tag elenco file manifesto anziché il tag specifico della piattaforma.
```
sudo -E podman run --rm --detach --init --publish 5808:5808 $OCIR_INSTANCE/$OCIR_NAMESPACE/demo/rasdash:0.3.4
```

Creare ed eseguire l'immagine in remoto.

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

Test delle immagini mediante un browser

Si supponga di aver creato le regole di entrata e le regole firewall necessarie nelle istanze. In tal caso, si dovrebbe essere in grado di aprire il browser e andare a http://<PUBLIC_IP_ADDRESS_OF_ORACLE_CLOUD_DEVELOPER_INSTANCE>:5808 e http://<PUBLIC_IP_ADDRESS_OF_PODMAN_SERVER_INSTANCE>:5808 per aprire l'applicazione Web RasDash in esecuzione su ogni istanza.

In caso contrario, è possibile utilizzare l'inoltro della porta SSH come prima creando due tunnel dal computer locale.

Aprire un tunnel SSH per l'istanza di Oracle Cloud Developer.
```
ssh -L 5808:localhost:5808 -i <SSH_KEY> opc@<IP_ADDRESS_OF_ORACLE_CLOUD_DEVELOPER_INSTANCE>
```
Aprire un browser nel computer locale e andare a http://localhost:5808 per visualizzare l'applicazione Web basata su arm64 nell'istanza di Cloud Development.
Uscire dalla sessione del tunnel SSH.
Aprire un tunnel SSH per l'istanza del server Podman.
```
ssh -L 5808:localhost:5808 -i <SSH_KEY> opc@<IP_ADDRESS_OF_PODMAN_SERVER_INSTANCE>
```
Aggiornare il browser sul computer locale che punta a http://localhost:5808 per visualizzare l'applicazione Web basata su amd64 nell'istanza del server Podman.

Passi successivi

Dopo aver completato questa esercitazione, è ora necessario sapere come creare immagini che è possibile distribuire da entrambi i repository OCIR privati e pubblici. È possibile utilizzare queste immagini in varie posizioni, ad esempio Oracle Engine for Kubernetes (OKE) o Oracle Cloud Native Environment. Quando si distribuiscono le immagini su host esterni a Oracle Cloud Infrastructure, incluso Podman Desktop per Mac o Windows, è necessario assicurarsi che il repository sia pubblico.

Altre risorse di apprendimento

Esplora altri laboratori su docs.oracle.com/learn o accedi a più contenuti di formazione gratuiti sul canale YouTube di Oracle Learning. Inoltre, visitare education.oracle.com/learning-explorer per diventare Oracle Learning Explorer.

Per la documentazione del prodotto, visitare Oracle Help Center.

Titolo e informazioni sul copyright

Build Multi-Platform Container Images Using Podman on Oracle Linux

F50002-04

Oracle e/o relative consociate.