Compartilhar via

Criar imagem para a máquina virtual do Azure Operator Nexus.

Neste artigo, você aprenderá a criar uma imagem de contêiner que pode ser usada para criar uma máquina virtual no Operador Nexus. Especificamente, você aprenderá a adicionar um disco virtual à imagem de contêiner. Depois que a imagem de contêiner for criada e enviada por push para um registro de contêiner do Azure, ela poderá ser usada para criar uma máquina virtual no Operador Nexus.

Pré-requisitos

Antes de começar a criar uma imagem de VM (máquina virtual), verifique se você tem os seguintes pré-requisitos em vigor:

  • Instale a versão mais recente das extensões necessárias da CLI do Azure.

  • Este artigo requer a versão 2.61.0 ou posterior da CLI do Azure. Se você está usando o Azure Cloud Shell, a versão mais recente já está instalada.

  • Registro de Contêiner do Azure (ACR): configure um Registro de Contêiner do Azure em funcionamento para armazenar e gerenciar suas imagens de contêiner. O ACR fornece um registro seguro e privado para armazenar imagens do Docker usadas no processo de criação de imagem da VM. Você pode criar um ACR seguindo a documentação oficial no Registro de Contêiner do Azure.

  • Docker: instale o Docker no computador local. O Docker é uma plataforma que permite criar, empacotar e distribuir aplicativos como contêineres leves. Você usa o Docker para criar e empacotar sua imagem de VM. Você pode baixar o Docker no site oficial do Docker.

Observação

Você pode usar o az login comando para autenticar com o Azure e o script executará automaticamente o logon do ACR usando o nome do ACR e a ID da assinatura fornecidas. Se você não tiver a CLI do Azure instalada em seu computador, você poderá fornecer seu nome de usuário e senha para logon do ACR.

Verifique se você tem um Registro de Contêiner do Azure (ACR) operacional e o Docker instalados em seu computador antes de prosseguir com a criação de uma imagem de VM. Familiarize-se com o uso e a funcionalidade do ACR e do Docker, pois eles são essenciais para gerenciar suas imagens de contêiner e compilar a imagem da VM.

Requisitos de imagem de máquina virtual

  • Verifique se a imagem da VNF (Função de Rede Virtual) está no formato qcow2 que pode ser inicializada com cloud-init.

  • Você precisa configurar o sistema bootloader, kernel e init em sua imagem para habilitar a conectividade serial e o console baseado em texto. Use as configurações de cmdline do GRUB_TERMINAL="console serial" e do kernel. Essa configuração é necessária para habilitar o acesso serial para solucionar problemas de implantação e suporte de console para sua VM (máquina virtual) após a implantação. Verifique se as configurações de porta serial em seu sistema e terminal correspondem para estabelecer a comunicação adequada.

  • Você precisa garantir que sua imagem de VM dê suporte à versão 2 do cloud-init, habilitando opções de configuração avançadas durante o processo de inicialização da VM.

  • Você precisa garantir que sua imagem de VM inclua cloud-init com a nocloud fonte de dados. nocloud A fonte de dados permite a configuração inicial e a personalização durante o provisionamento de VM.

  • Os discos devem ser colocados no /disk diretório dentro do contêiner.

  • Há suporte para formatos raw e qcow2. O Qcow2 é recomendado para reduzir o tamanho da imagem do contêiner.

  • Os discos de contêiner devem ser baseados na scratch imagem, que é uma imagem base vazia que não contém arquivos ou diretórios diferentes da imagem em si. Usar scratch como imagem base garante que a imagem de contêiner seja o menor possível e inclua apenas os arquivos necessários para a VNF.

Etapas para criar uma imagem para a máquina virtual Operator Nexus

Você pode criar uma imagem para sua VNF usando o script fornecido. Ele gera um Dockerfile que copia o arquivo de imagem de disco VNF no diretório do /disk contêiner.

Observação

O script a seguir é fornecido como um exemplo. Se preferir, você pode criar e efetuar push da imagem de contêiner manualmente em vez de seguir o script.

As variáveis de ambiente a seguir são usadas para configurar o script para criar uma imagem de VM (máquina virtual) para sua VNF. Modifique e exporte essas variáveis com seus próprios valores antes de executar o 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=""

Para criar uma imagem de VM para sua VNF (Função de Rede Virtual), salve o script fornecido como create-container-disk.sh, defina as variáveis de ambiente necessárias e execute o 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!"

Depois de executar o script, você terá uma imagem de VM adaptada para sua VNF (Função de Rede Virtual). Você pode usar essa imagem para implantar sua VNF.

Observação

Para garantir que a imagem VNF possa ser puxada corretamente, verifique se a URL do ACR está na lista de permissões de saída da rede de serviços de nuvem que você usará com sua máquina virtual Operator Nexus.

Exemplo de uso

  1. Defina as variáveis de ambiente necessárias.

    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"

  2. Salve o script fornecido como create-container-disk.sh e torne-o executável.

    chmod +x create-container-disk.sh

  3. Execute o 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!

Próximas etapas

Consulte o guia de Início Rápido para implantar uma VNF usando a imagem que você criou.

  • Last updated on