Criar infraestrutura do Azure AKS

Neste artigo, fornece os recursos essenciais do Azure necessários para uma implementação AKS pronta para produção. Este artigo valida o acesso Azure, cria um grupo de recursos, estabelece um Azure Container Registry (ACR), implementa um cluster base AKS, adiciona opcionalmente um pool de nós adicional para cargas de trabalho dos utilizadores e concede ao cluster permissão para extrair do ACR. Todos os comandos dependem de variáveis de ambiente parametrizadas, pelo que o fluxo de trabalho permanece repetível entre regiões e subscrições.

Pré-requisitos

Precisa das seguintes ferramentas e acesso à conta antes de executar o guia. Certifica-te de que estás autenticado no Azure usando az login e que tens permissões suficientes para criar grupos de recursos, registos de contentores e clusters AKS.

• Subscrição Azure com quota para a região selecionada
• Azure CLI (az) com direitos de Proprietário ou Contribuidor
• Kubectl configurado localmente para acesso ao cluster
• jq (opcional) para análise da saída JSON durante a verificação

Execute os seguintes comandos para confirmar que tem todas as ferramentas de CLI necessárias e 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, defines todas as variáveis de ambiente usadas ao longo dos passos de provisionamento. A HASH marca temporal garante a exclusividade dos nomes dos recursos durante execuções repetidas. As predefinições de cluster e registro destinam-se a uma pegada mínima para prova de conceito, mas pode ajustá-las conforme necessário.

Os comandos seguintes estabelecem as definições de âmbito no Azure, o dimensionamento do AKS e as convenções de nomenclatura para o ACR na sequência de provisionamento, independentemente das cargas de trabalho subsequentes.

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 os valores das variáveis de ambiente

Revise a configuração eficaz antes de criar os recursos. Reexecute o bloco após quaisquer ajustes para garantir que os valores ativos estão corretos para a subscrição e região alvo.

Use os seguintes comandos para pintar os parâmetros ativos e validar nomes, tamanhos e escolhas regionais.

: "${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 passo sequencialmente. Cada subseção inclui o propósito, comandos e um resumo para confirmar os resultados esperados.

Verifique o contexto de subscrição do Azure

Verifique a subscrição ativa do Azure e assegure que os fornecedores de recursos necessários para operações AKS e ACR estão registados.

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

Criar um grupo de recursos

Providencie um grupo de recursos dedicado para isolar o cluster AKS, o registo e a infraestrutura de suporte para as suas cargas de trabalho.

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

Provisionar o Azure Container Registry

Crie um Azure Container Registry para armazenar imagens de contentores e autentique o daemon local do Docker para enviar imagens.

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 AKS

Implementa o cluster AKS para alojar as tuas cargas de trabalho. Proteja-te contra a reutilização 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 um conjunto de nós de utilizador opcional

Providencie um pool adicional de nós quando solicitado. O comando add executa-se de forma assíncrona para evitar timeouts da CLI; o comando de espera acompanha o progresso de Azure. O script verifica primeiro se o pool já existe para evitar erros de nomes 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 do cluster

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

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

Anexar ACR ao cluster AKS

Conceda ao cluster AKS permissão para extrair imagens do ACR provisionado para que futuras implementações possam aceder às imagens do seu contentor.

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

Verification

Confirme que o cluster AKS existe e responde a consultas básicas kubectl antes de continuar para os passos de implementação a jusante. Comece por garantir que o cluster AKS existe.

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 AKS tiver sido criado, verá algo como:

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

De seguida, verifique se kubectl está corretamente configurado:

kubectl cluster-info

Este comando irá apresentar o estado do cluster atual, algo como:

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

Por fim, certifique-se de que existem tanto nós do sistema como de utilizador disponíveis:

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

Isto irá gerar uma contagem de nós, algo como:

      1 system
      1 user

Resumo: Validado que o cluster AKS está presente, saudável e acessível via kubectl no contexto atual.

Resumo

O grupo de recursos, o registo de contentores, o cluster AKS, o pool opcional de nós e o anexo do registo são validados, deixando o cluster pronto para quaisquer cargas de trabalho containerizadas.

Próximas Etapas

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