Criar infraestrutura do AKS do Azure

Neste artigo, você provisiona os principais recursos do Azure necessários para uma implantação do AKS pronta para produção. Este artigo valida o acesso do Azure, cria um grupo de recursos, estabelece um ACR (Registro de Contêiner do Azure), implanta um cluster AKS de linha de base, adiciona opcionalmente um pool de nós adicional para cargas de trabalho do usuário e concede permissão de cluster para efetuar pull do ACR. Todos os comandos dependem de variáveis de ambiente parametrizadas para que o fluxo de trabalho permaneça repetível entre regiões e assinaturas.

Pré-requisitos

Você precisa das seguintes ferramentas e acesso à conta antes de seguir o guia. Verifique se você está autenticado no Azure usando az login e tenha permissões suficientes para criar grupos de recursos, registros de contêiner e clusters do AKS.

• Assinatura do Azure com cota para a região selecionada
• CLI do Azure (az) com direitos de Proprietário ou Colaborador
• kubectl configurado localmente para acesso ao cluster
• jq (opcional) para analisar a saída JSON durante a verificação

Execute os seguintes comandos para confirmar se você tem todas as ferramentas necessárias da CLI e o acesso ao Azure:

command -v az >/dev/null || echo "Azure CLI missing"
command -v kubectl >/dev/null || echo "kubectl missing"
command -v jq >/dev/null || echo "jq missing (optional)"

Configurar o ambiente

Aqui, você define todas as variáveis de ambiente usadas em todas as etapas de provisionamento. O carimbo de data/hora HASH mantém os nomes de recursos exclusivos durante execuções repetidas. As configurações padrão do cluster e do registro visam uma implementação mínima para fins de prova de conceito, mas você pode ajustá-las conforme necessário.

Os comandos a seguir estabelecem o escopo do Azure, o dimensionamento do AKS e as convenções de nomenclatura do ACR para a sequência de provisionamento, independentemente das cargas de trabalho downstream.

export HASH="${HASH:-$(date -u +"%y%m%d%H%M")}"  # YYMMDDHHMM stamp

# Azure scope and regional placement
export LOCATION="${LOCATION:-eastus2}"
export SUBSCRIPTION_ID="${SUBSCRIPTION_ID:-$(az account show --query id -o tsv)}"
export RESOURCE_GROUP="${RESOURCE_GROUP:-rg_aks_${HASH}}"

# AKS cluster naming and version control
# Hyphen required because AKS cluster names cannot include underscores
export AKS_CLUSTER_NAME="${AKS_CLUSTER_NAME:-aks-openwebsearch-${HASH}}"
export AKS_VERSION="${AKS_VERSION:-}"  # Optional Kubernetes version override

# Node pool sizing
export AKS_SYSTEM_NODE_COUNT="${AKS_SYSTEM_NODE_COUNT:-1}"
export AKS_USER_NODE_COUNT="${AKS_USER_NODE_COUNT:-1}"
export AKS_NODE_VM_SIZE="${AKS_NODE_VM_SIZE:-Standard_D4s_v5}"
export AKS_SYSTEM_NODEPOOL_NAME="${AKS_SYSTEM_NODEPOOL_NAME:-system}"
export AKS_USER_NODEPOOL_NAME="${AKS_USER_NODEPOOL_NAME:-user}"

# ACR configuration
export ACR_NAME="${ACR_NAME:-acrwebsearch${HASH}}"
export ACR_LOGIN_SERVER="${ACR_LOGIN_SERVER:-${ACR_NAME}.azurecr.io}"

Verificar valores de variável de ambiente

Examine a configuração efetiva antes de criar recursos. Execute novamente o bloco após quaisquer ajustes para garantir que os valores ativos estejam corretos para a assinatura e a região de destino.

Utilize os seguintes comandos para definir os parâmetros ativos e validar as opções de nomenclatura, tamanho e região.

: "${HASH:=$(date -u +"%y%m%d%H%M")}"  # Ensure HASH exists

VARS=(
  HASH
  LOCATION
  SUBSCRIPTION_ID
  RESOURCE_GROUP
  AKS_CLUSTER_NAME
  AKS_VERSION
  AKS_SYSTEM_NODE_COUNT
  AKS_USER_NODE_COUNT
  AKS_NODE_VM_SIZE
  AKS_SYSTEM_NODEPOOL_NAME
  AKS_USER_NODEPOOL_NAME
  ACR_NAME
  ACR_LOGIN_SERVER
)
for v in "${VARS[@]}"; do
  printf "%s=%s\n" "$v" "${!v}"
done

Steps

Execute cada etapa sequencialmente. Cada subseção inclui finalidade, comandos e um resumo para confirmar os resultados esperados.

Verificar o contexto da assinatura do Azure

Verifique a assinatura ativa do Azure e verifique se os provedores de recursos necessários para operações do AKS e do ACR estão registrados.

az account show --query id -o tsv
az provider register --namespace Microsoft.ContainerService
az provider register --namespace Microsoft.ContainerRegistry

Criar um grupo de recursos

Provisione um grupo de recursos dedicado para isolar o cluster do AKS, o registro e a infraestrutura de suporte para suas cargas de trabalho.

az group create \
  --name "${RESOURCE_GROUP}" \
  --location "${LOCATION}" \
  --output table

Provisionar o Registro de Contêiner do Azure

Crie um Registro de Contêiner do Azure para armazenar imagens de contêiner e autenticar o daemon local do Docker para enviar imagens por push.

az acr create \
  --name "${ACR_NAME}" \
  --resource-group "${RESOURCE_GROUP}" \
  --location "${LOCATION}" \
  --sku Basic \
  --output table
az acr login --name "${ACR_NAME}"

Criar o Cluster do AKS

Implante o cluster do AKS para hospedar suas cargas de trabalho. Proteja-se contra reutilizações de um nome de cluster existente verificando antes da criação.

if az aks show \
  --name "${AKS_CLUSTER_NAME}" \
  --resource-group "${RESOURCE_GROUP}" >/dev/null 2>&1; then
  echo "AKS cluster ${AKS_CLUSTER_NAME} already exists in ${RESOURCE_GROUP}";
  echo "Skip creation or provide a new AKS_CLUSTER_NAME.";
else
  az aks create \
    --name "${AKS_CLUSTER_NAME}" \
    --resource-group "${RESOURCE_GROUP}" \
    --location "${LOCATION}" \
    --generate-ssh-keys \
    --node-count "${AKS_SYSTEM_NODE_COUNT}" \
    --nodepool-name "${AKS_SYSTEM_NODEPOOL_NAME}" \
    --node-vm-size "${AKS_NODE_VM_SIZE}" \
    ${AKS_VERSION:+--kubernetes-version "${AKS_VERSION}"} \
    --output table
fi

Adicionar pool de nós de usuário opcional

Provisione um pool de nós adicional quando solicitado. O comando add é executado de forma assíncrona para evitar tempos limite da CLI; o comando de espera acompanha o progresso do Azure. O script primeiro verifica se o pool já existe para evitar erros de nome duplicados.

if [ "${AKS_USER_NODE_COUNT}" -gt 0 ]; then
  if az aks nodepool show \
    --cluster-name "${AKS_CLUSTER_NAME}" \
    --resource-group "${RESOURCE_GROUP}" \
    --name "${AKS_USER_NODEPOOL_NAME}" >/dev/null 2>&1; then
    echo "Node pool ${AKS_USER_NODEPOOL_NAME} already exists; skipping add.";
  else
    az aks nodepool add \
      --cluster-name "${AKS_CLUSTER_NAME}" \
      --resource-group "${RESOURCE_GROUP}" \
      --name "${AKS_USER_NODEPOOL_NAME}" \
      --node-count "${AKS_USER_NODE_COUNT}" \
      --node-vm-size "${AKS_NODE_VM_SIZE}" \
      --no-wait
    az aks nodepool wait \
      --cluster-name "${AKS_CLUSTER_NAME}" \
      --resource-group "${RESOURCE_GROUP}" \
      --name "${AKS_USER_NODEPOOL_NAME}" \
      --created
  fi
fi

Recuperar credenciais de cluster

Incorpore o arquivo kubeconfig do AKS no contexto local e verifique se todos os nós estão acessíveis.

az aks get-credentials \
  --name "${AKS_CLUSTER_NAME}" \
  --resource-group "${RESOURCE_GROUP}" \
  --overwrite-existing
kubectl get nodes -o wide

Anexar o ACR ao cluster do AKS

Conceda permissão ao cluster do AKS para obter imagens do ACR provisionado, de modo que futuras implementações possam acessar suas imagens de contêiner.

az aks update \
  --name "${AKS_CLUSTER_NAME}" \
  --resource-group "${RESOURCE_GROUP}" \
  --attach-acr "${ACR_NAME}" \
  --output table

Verificação

Confirme se o cluster do AKS existe e responde a consultas básicas kubectl antes de continuar com as etapas de implantação downstream. Comece garantindo que o cluster do AKS exista.

if ! az aks show \
  --name "${AKS_CLUSTER_NAME}" \
  --resource-group "${RESOURCE_GROUP}" \
  --query "{name:name,provisioningState:provisioningState,location:location}" \
  --output table; then
  echo "AKS cluster '${AKS_CLUSTER_NAME}' not found in resource group '${RESOURCE_GROUP}'."
else
  echo "AKS cluster '${AKS_CLUSTER_NAME}' exists in resource group '${RESOURCE_GROUP}'."
fi

Se o cluster do AKS tiver sido criado, você verá algo como:

AKS cluster ${AKS_CLUSTER_NAME} exists in resource group ${RESOURCE_GROUP}.

Em seguida, verifique kubectl se está configurado corretamente:

kubectl cluster-info

Esse comando gerará o status do cluster atual, algo como:

Kubernetes control plane is running at ...
CoreDNS is running at https://...
Metrics-server is running at https://...

Por fim, verifique se há nós de sistema e de usuário disponíveis:

kubectl get nodes -o jsonpath='{range .items[*]}{.metadata.labels.agentpool}{"\n"}{end}' |
  sort |
  uniq -c

Isso exibirá uma contagem de nós, algo como:

      1 system
      1 user

Resumo: Validou que o cluster do AKS está presente, íntegro e acessível por meio do kubectl no contexto atual.

Resumo

O grupo de recursos, o registro de contêiner, o cluster AKS, o pool de nós opcional e a conexão de registro são validados, deixando o cluster pronto para quaisquer cargas de trabalho em contêineres.

Próximas etapas

• Prossiga com docs/OpenWebSearch_On_AKS.md para implementar o KMCP e o servidor MCP
• Configurar atribuições de função ou políticas de rede específicas à sua postura de segurança
• Integrar o Azure Monitor ou o Log Analytics para visibilidade operacional
• Executar comandos de limpeza de infraestrutura após a experimentação para gerenciar custos