Creare un'immagine per la macchina virtuale Operatore Nexus di Azure

Articolo
09/26/2024

Questo articolo illustra come creare un'immagine del contenitore che può essere usata per creare una macchina virtuale in Operatore Nexus. In particolare, si apprenderà come aggiungere un disco virtuale all'immagine del contenitore. Dopo aver compilato ed eseguito il push dell'immagine del contenitore in un Registro Azure Container, può essere usata per creare una macchina virtuale in Operatore Nexus.

Prerequisiti

Prima di iniziare a creare un'immagine di macchina virtuale, assicurarsi di disporre dei prerequisiti seguenti:

Installare la versione più recente delle estensioni dell'interfaccia della riga di comando di Azure necessarie.
Questo articolo richiede la versione 2.61.0 o successiva dell'interfaccia della riga di comando di Azure. Se si usa Azure Cloud Shell, la versione più recente è già installata.
Registro Azure Container: configurare un Registro Azure Container funzionante per archiviare e gestire le immagini del contenitore. Registro Azure Container offre un registro sicuro e privato per l'archiviazione di immagini Docker usate nel processo di creazione dell'immagine della macchina virtuale. È possibile creare un Registro Azure Container seguendo la documentazione ufficiale del Registro Azure Container.
Docker: installare Docker nel computer locale. Docker è una piattaforma che consente di compilare, creare pacchetti e distribuire applicazioni come contenitori leggeri. Si usa Docker per compilare e creare un pacchetto dell'immagine della macchina virtuale. È possibile scaricare Docker dal sito Web ufficiale di Docker.

Nota

È possibile usare il comando az login per eseguire l'autenticazione con Azure e lo script eseguirà automaticamente l'accesso del Registro Azure Container usando il nome del Registro Azure Container e l'ID sottoscrizione specificati. Se nel computer non è installata l'interfaccia della riga di comando di Azure, è possibile invece specificare il nome utente e la password per l'account di accesso di Registro Azure Container.

Assicurarsi che nel computer sia installato un Registro Azure Container operativo e Docker prima di procedere con la creazione di un'immagine di macchina virtuale. Acquisire familiarità con l'uso e le funzionalità di Registro Azure Container e Docker, perché sono essenziali per la gestione delle immagini del contenitore e la creazione dell'immagine della macchina virtuale.

Requisiti dell'immagine della macchina virtuale

Verificare che l'immagine della funzione di rete virtuale (VNF) sia in formato qcow2, avviabile con cloud-init.
È necessario configurare il bootloader, il kernel e il sistema init nell'immagine per abilitare una console seriale basata su testo. Questa configurazione è necessaria per abilitare il supporto della console per la macchina virtuale. Assicurarsi che le impostazioni della porta seriale nel sistema e nel terminale corrispondano per stabilire una comunicazione corretta.
È necessario assicurarsi che l'immagine della macchina virtuale supporti cloud-init versione 2, abilitando le opzioni di configurazione avanzate durante il processo di inizializzazione della macchina virtuale.
È necessario assicurarsi che l'immagine della macchina virtuale includa cloud-init con l'origine dati nocloud. L'origine dati nocloud consente la configurazione iniziale e la personalizzazione durante il provisioning delle macchine virtuali.
I dischi devono essere inseriti nella directory /disk all'interno del contenitore.
Sono supportati formati raw e qcow2. Qcow2 è consigliato per ridurre le dimensioni dell'immagine del contenitore.
I dischi dei contenitori devono essere basati sull'immagine scratch, ovvero un'immagine di base vuota che non contiene file o directory diverse dall'immagine stessa. L'uso di scratch come immagine di base garantisce che l'immagine del contenitore sia il più piccola possibile e includa solo i file necessari per la funzione di rete virtualizzata.

Procedura per creare un'immagine per la macchina virtuale Operatore Nexus

È possibile creare un'immagine per il VNF usando lo script fornito. Genera un Dockerfile che copia il file di immagine del disco VNF nella directory /disk del contenitore.

Nota

Lo script seguente viene fornito come esempio. Se si preferisce, è possibile creare ed eseguire manualmente il push dell'immagine del contenitore anziché seguire lo script.

Le variabili di ambiente seguenti vengono usate per configurare lo script per la creazione di un'immagine di macchina virtuale per la funzione di rete virtualizzata. Modificare ed esportare queste variabili con valori personalizzati prima di eseguire lo script:


# Azure subscription ID (provide if not using username-password)
export SUBSCRIPTION="your_subscription_id"

# (Mandatory) Azure Container Registry name
export ACR_NAME="your_acr_name"

# (Mandatory) Name of the container image
export CONTAINER_IMAGE_NAME="your_container_image_name"

# (Mandatory) Tag for the container image
export CONTAINER_IMAGE_TAG="your_container_image_tag"

# (Mandatory) VNF image (URL, local file, or full local path)
export VNF_IMAGE="your_vnf_image"

# (Optional) ACR URL (leave empty to derive from ACR_NAME)
export ACR_URL=""

# (Optional) ACR login username (provide if not using subscription)
export USERNAME=""

# (Optional) ACR login password (provide if not using subscription)
export PASSWORD=""

Per creare un'immagine di macchina virtuale per la funzione di rete virtuale (VNF), salvare lo script fornito come create-container-disk.sh, impostare le variabili di ambiente necessarie ed eseguire lo script.

#!/bin/bash

# Define the required environment variables
required_vars=(
    "ACR_NAME"                  # Azure Container Registry name
    "CONTAINER_IMAGE_NAME"      # Name of the container image
    "CONTAINER_IMAGE_TAG"       # Tag for the container image
    "VNF_IMAGE"                 # VNF image (URL or file path)
)

# Verify if required environment variables are set
for var in "${required_vars[@]}"; do
    if [ -z "${!var}" ]; then
        echo "Error: $var environment variable is not set."
        exit 1
    fi
done

# Check if either SUBSCRIPTION or USERNAME with PASSWORD is provided
if [ -z "$SUBSCRIPTION" ] && [ -z "$USERNAME" ] && [ -z "$PASSWORD" ]; then
    echo "Error: Either provide SUBSCRIPTION or USERNAME with PASSWORD."
    exit 1
fi

# Set default value for DOCKERFILE_NAME if not set
if [ -z "$DOCKERFILE_NAME" ]; then
    DOCKERFILE_NAME="nexus-vm-img-dockerfile"
fi

# Check if ACR_URL is already set by the user
if [ -z "$ACR_URL" ]; then
    # Derive the ACR URL from the ACR_NAME
    ACR_URL="$ACR_NAME.azurecr.io"
fi

# Initialize variables for downloaded/copied files
downloaded_files=()

# Function to clean up downloaded files
cleanup() {
    for file in "${downloaded_files[@]}"; do
        if [ -f "$file" ]; then
            rm "$file"
        fi
    done
}

# Register the cleanup function to be called on exit
trap cleanup EXIT

# Check if the VNF image is a URL or a local file
if [[ "$VNF_IMAGE" == http* ]]; then
    # Use curl to download the file
    filename=$(basename "$VNF_IMAGE")
    # Download the VNF image file and save the output to a file
    curl -f -Lo "$filename" "$VNF_IMAGE"
    if [ $? -ne 0 ]; then
        echo "Error: Failed to download file."
        exit 1
    fi
    # Add the downloaded file to the list for cleanup
    downloaded_files+=("$filename")
elif [[ "$VNF_IMAGE" == /* ]]; then
    # Use the provided full local path
    filename=$(basename "$VNF_IMAGE")
    # Copy the VNF image file to the current directory for cleanup
    cp "$VNF_IMAGE" "./$filename"
    # Add the copied file to the list for cleanup
    downloaded_files+=("$filename")
else
    # Assume it's a local file in the current directory
    filename="$VNF_IMAGE"
fi

# Check if the file exists
if [ ! -f "$filename" ]; then
    echo "Error: File $filename does not exist."
    exit 1
fi

# Create a Dockerfile that copies the VNF image file into the container's /disk directory
# The containerDisk needs to be readable for the user with the UID 107 (qemu).
cat <<EOF > "$DOCKERFILE_NAME"
FROM scratch
ADD --chown=107:107 "$filename" /disk/
EOF

# Build the Docker image and tag it to the Azure Container Registry
docker build -f "$DOCKERFILE_NAME" -t "$CONTAINER_IMAGE_NAME:$CONTAINER_IMAGE_TAG" .

# Log in to Azure Container Registry
if [ -n "$USERNAME" ] && [ -n "$PASSWORD" ]; then
    docker login "$ACR_NAME.azurecr.io" -u "$USERNAME" -p "$PASSWORD"
else
    az acr login --name "$ACR_NAME" --subscription "$SUBSCRIPTION"
fi

docker tag "$CONTAINER_IMAGE_NAME:$CONTAINER_IMAGE_TAG" "$ACR_URL/$CONTAINER_IMAGE_NAME:$CONTAINER_IMAGE_TAG"
docker push "$ACR_URL/$CONTAINER_IMAGE_NAME:$CONTAINER_IMAGE_TAG"

# Remove the downloaded/copied files
cleanup

rm "$DOCKERFILE_NAME"

echo "VNF image $ACR_URL/$CONTAINER_IMAGE_NAME:$CONTAINER_IMAGE_TAG created successfully!"

Dopo aver eseguito lo script, si avrà un'immagine di macchina virtuale personalizzata per la funzione di rete virtuale (VNF). È possibile usare questa immagine per distribuire il VNF.

Nota

Per assicurarsi che l'immagine della funzione di rete virtualizzata possa essere estratta correttamente, assicurarsi che l'URL del Registro Azure Container si trovi nell'elenco di elementi consentiti della rete di servizi cloud che verrà usata con la macchina virtuale Operatore Nexus.

Esempio di utilizzo

Impostare le variabili di ambiente necessarie.

export SUBSCRIPTION=""00000000-0000-0000-0000-000000000000""
export ACR_NAME="myvnfacr"
export CONTAINER_IMAGE_NAME="ubuntu"
export CONTAINER_IMAGE_TAG="20.04"
export VNF_IMAGE="https://cloud-images.ubuntu.com/releases/focal/release/ubuntu-20.04-server-cloudimg-amd64.img"

Salvare lo script fornito come create-container-disk.sh e renderlo eseguibile.
```
chmod +x create-container-disk.sh
```

Eseguire lo script.

$ ./create-container-disk.sh
  % Total    % Received % Xferd  Average Speed   Time    Time     Time  Current
                                 Dload  Upload   Total   Spent    Left  Speed
100  622M  100  622M    0     0  24.7M      0  0:00:25  0:00:25 --:--:-- 26.5M
[+] Building 36.6s (5/5) FINISHED
 => [internal] load .dockerignore                                                              0.1s
 => => transferring context: 2B                                                                0.0s
 => [internal] load build definition from nexus-vm-img-dockerfile                              0.1s
 => => transferring dockerfile: 137B                                                           0.0s
 => [internal] load build context                                                              36.4s
 => => transferring context: 652.33MB                                                          36.3s
 => CACHED [1/1] ADD --chown=107:107 ubuntu-20.04-server-cloudimg-amd64.img /disk/             0.0s
 => exporting to image                                                                         0.0s
 => => exporting layers                                                                        0.0s
 => => writing image sha256:5b5f531c132cdbba202136b5ec41c9bfe9d91beeb5acee617c1ef902df4ca772   0.0s
 => => naming to docker.io/library/ubuntu:20.04                                                0.0s
Login Succeeded
The push refers to repository [myvnfacr.azurecr.io/ubuntu]
b86efae7de58: Layer already exists
20.04: digest: sha256:d514547ee28d9ed252167d0943d4e711547fda95161a3728c44a275f5d9669a8 size: 529
VNF image myvnfacr.azurecr.io/ubuntu:20.04 created successfully!

Passaggi successivi

Fare riferimento alla guida introduttiva per distribuire una funzione di rete virtualizzata usando l'immagine creata.

Condividi tramite

Creare un'immagine per la macchina virtuale Operatore Nexus di Azure

Prerequisiti

Requisiti dell'immagine della macchina virtuale

Procedura per creare un'immagine per la macchina virtuale Operatore Nexus

Esempio di utilizzo

Passaggi successivi

Commenti e suggerimenti

Risorse aggiuntive