Guia de início rápido: conclua os pré-requisitos para implantar uma função de rede conteinerizada no Azure Operator Service Manager

Artigo
11/08/2023

Neste Guia de início rápido, você conclui as tarefas necessárias antes de usar o Azure Operator Service Manager (AOSM).

Pré-requisitos

Entre em contato com sua equipe de conta da Microsoft para registrar sua assinatura do Azure para acessar o Azure Operator Service Manager (AOSM) ou expressar seu interesse por meio do formulário de registro de parceiro.

Baixar e instalar a CLI do Azure

Use o ambiente Bash no shell de nuvem do Azure. Para obter mais informações, consulte Iniciar o Cloud Shell para usar o ambiente Bash no Azure Cloud Shell .

Para usuários que preferem executar comandos de referência da CLI localmente, consulte Como instalar a CLI do Azure.

Se você estiver executando no Windows ou macOS, considere executar a CLI do Azure em um contêiner do Docker. Para obter mais informações, consulte Como executar a CLI do Azure em um contêiner do Docker.

Se você estiver usando uma instalação local, entre na CLI do Azure usando o az login comando e conclua os prompts exibidos em seu terminal para concluir a autenticação. Para obter mais opções de entrada, consulte Entrar com a CLI do Azure.

Instalar a extensão da CLI do Azure Operator Service Manager (AOSM)

Instale a extensão da CLI do Azure Operator Service Manager (AOSM) usando este comando:

az extension add --name aosm

Execute az version para ver a versão e as bibliotecas dependentes que estão instaladas.
Execute az upgrade para atualizar para a versão atual da CLI do Azure.

Registrar e verificar os provedores de recursos necessários

Antes de começar a usar o Azure Operator Service Manager, execute os seguintes comandos para registrar o provedor de recursos necessário. Este processo de registo pode demorar até 5 minutos.

# Register Resource Provider
az provider register --namespace Microsoft.HybridNetwork
az provider register --namespace Microsoft.ContainerRegistry

Verifique o status de registro dos provedores de recursos. Execute os seguintes comandos.

# Query the Resource Provider
az provider show -n Microsoft.HybridNetwork --query "{RegistrationState: registrationState, ProviderName: namespace}"
az provider show -n Microsoft.ContainerRegistry --query "{RegistrationState: registrationState, ProviderName: namespace}"

Nota

Pode levar alguns minutos para que o registro do provedor de recursos seja concluído. Depois que o registro for bem-sucedido, você poderá continuar usando o Azure Operator Service Manager (AOSM).

Requisitos para a função de rede conteinerizada (CNF)

Para aqueles que utilizam funções de rede conteinerizadas, é essencial garantir que os seguintes pacotes sejam instalados na máquina a partir da qual você está executando a CLI:

Instalar o docker, consulte Instalar o mecanismo do Docker.
Instale o Helm, consulte Install Helm CLI.

Configurar a implantação da Função de Rede em Contêiner (CNF)

Para implantações de CNFs (Containerized Network Functions), é crucial ter o seguinte armazenado na máquina a partir da qual você está executando a CLI:

Pacotes Helm com Esquema - Esses pacotes devem estar presentes em seu armazenamento local e referenciados input.json no arquivo de configuração. Ao seguir este início rápido, você baixa o pacote de leme necessário.
Criando um arquivo de configuração de exemplo - Gere um arquivo de configuração de exemplo para definir uma implantação CNF. Execute este comando para gerar um input.json arquivo que você precisa preencher com sua configuração específica.
```
az aosm nfd generate-config --definition-type cnf
```
Imagens para o seu CNF - Aqui estão as opções:
- Uma referência a um Registro de Contêiner do Azure existente que contém as imagens para seu CNF. Atualmente, apenas um ACR e namespace são suportados por CNF. As imagens a serem copiadas deste ACR são preenchidas automaticamente com base no esquema do pacote helm. Você deve ter permissões Reader/AcrPull neste ACR. Para usar essa opção, preencha source_registry e, opcionalmente source_registry_namespace , o arquivo input.json.
- O nome da imagem do docker de origem da máquina local. Este nome de imagem é para um caso de uso limitado em que o CNF requer apenas uma única imagem docker que existe no repositório docker local. Para usar essa opção, preencha source_local_docker_image o arquivo input.json. Requer que o docker seja instalado. Este guia de início rápido orienta você através do download de uma imagem do docker nginx para usar nessa opção.
Opcional: Arquivo de mapeamento (path_to_mappings): Opcionalmente, você pode fornecer um arquivo (no disco) chamado path_to_mappings. Esse arquivo deve espelhar values.yamlo , com os valores selecionados substituídos por parâmetros de implantação. Ao fazê-lo, expõe-os como parâmetros ao CNF. Ou, você pode deixar isso em input.json branco e a CLI gera o arquivo. Por padrão, nesse caso, cada valor dentro values.yaml é exposto como um parâmetro de implantação. Como alternativa, use o --interactive argumento CLI para fazer escolhas interativamente. Este guia de início rápido orienta você através da criação deste arquivo.

Ao configurar o input.json arquivo, certifique-se de listar os pacotes Helm na ordem em que devem ser implantados. Por exemplo, se o pacote "A" deve ser implantado antes do pacote "B", você input.json deve se assemelhar à seguinte estrutura:

"helm_packages": [
    {
        "name": "A",
        "path_to_chart": "Path to package A",
        "path_to_mappings": "Path to package A mappings",
        "depends_on": [
            "Names of the Helm packages this package depends on"
        ]
    },
    {
        "name": "B",
        "path_to_chart": "Path to package B",
        "path_to_mappings": "Path to package B mappings",
        "depends_on": [
            "Names of the Helm packages this package depends on"
        ]
    }
]

Seguir essas diretrizes garante uma abordagem bem organizada e estruturada para implantar Funções de Rede Conteinerizadas (CNFs) com pacotes Helm e configurações associadas.

Baixar imagem nginx para repositório docker local

Para este início rápido, você baixa a imagem do docker nginx para o repositório local. A extensão da CLI do Azure Operator Service Manager (AOSM) envia a imagem de lá para o ACR do Repositório de Artefatos do Azure Operator Service Manager (AOSM). A extensão CLI também suporta a cópia da imagem de um ACR existente. Copiar a imagem é o caso de uso padrão esperado, mas é mais lento para um início rápido criar um ACR para copiar para que esse método não seja usado aqui.

Emita o seguinte comando: docker pull nginx:stable

Baixar exemplo de gráfico Helm

Faça o download do gráfico Helm de exemplo aqui Gráfico Helm de exemplo para uso com este início rápido.

Mergulhe nos gráficos do Helm

Esta seção apresenta um gráfico Helm básico que configura o nginx e o configura para ouvir em uma porta especificada. O gráfico Helm fornecido nesta seção já incorpora um values.schema.json arquivo.

Arquivo de exemplo values.schema.json

{
    "$schema": "http://json-schema.org/draft-07/schema",
    "additionalProperties": true,
    "properties": {
        "affinity": {
            "additionalProperties": false,
            "properties": {},
            "type": "object"
        },
        "fullnameOverride": {
            "type": "string"
        },
        "image": {
            "additionalProperties": false,
            "properties": {
                "pullPolicy": {
                    "type": "string"
                },
                "repository": {
                    "type": "string"
                },
                "tag": {
                    "type": "string"
                }
            },
            "type": "object"
        },
        "imagePullSecrets": {
            "items": {
                "anyOf": []
            },
            "type": "array"
        },
        "ingress": {
            "additionalProperties": false,
            "properties": {
                "annotations": {
                    "additionalProperties": false,
                    "properties": {},
                    "type": "object"
                },
                "enabled": {
                    "type": "boolean"
                },
                "hosts": {
                    "items": {
                        "anyOf": [
                            {
                                "additionalProperties": false,
                                "properties": {
                                    "host": {
                                        "type": "string"
                                    },
                                    "paths": {
                                        "items": {
                                            "anyOf": []
                                        },
                                        "type": "array"
                                    }
                                },
                                "type": "object"
                            }
                        ]
                    },
                    "type": "array"
                },
                "tls": {
                    "items": {
                        "anyOf": []
                    },
                    "type": "array"
                }
            },
            "type": "object"
        },
        "nameOverride": {
            "type": "string"
        },
        "nodeSelector": {
            "additionalProperties": false,
            "properties": {},
            "type": "object"
        },
        "podSecurityContext": {
            "additionalProperties": false,
            "properties": {},
            "type": "object"
        },
        "replicaCount": {
            "type": "integer"
        },
        "resources": {
            "additionalProperties": false,
            "properties": {},
            "type": "object"
        },
        "securityContext": {
            "additionalProperties": false,
            "properties": {},
            "type": "object"
        },
        "service": {
            "additionalProperties": false,
            "properties": {
                "port": {
                    "type": "integer"
                },
                "type": {
                    "type": "string"
                }
            },
            "type": "object"
        },
        "serviceAccount": {
            "additionalProperties": false,
            "properties": {
                "create": {
                    "type": "boolean"
                },
                "name": {
                    "type": "null"
                }
            },
            "type": "object"
        },
        "tolerations": {
            "items": {
                "anyOf": []
            },
            "type": "array"
        }
    },
    "type": "object"
}

Embora este artigo não se aprofunde nos meandros de Helm, alguns elementos que merecem destaque incluem:

Configuração da porta de serviço: O values.yaml tem uma predefinição com uma porta de serviço de 80.

Arquivo Sample.yaml

# Default values for nginxdemo. 
# This is a YAML-formatted file. 
# Declare variables to be passed into your templates. 

 
replicaCount: 1 
 

image: 

  # Repository gets overwritten by AOSM to the Artifact Store ACR, however we've hard-coded the image name and tag in deployment.yaml 

  repository: overwriteme 
  tag: stable 
  pullPolicy: IfNotPresent 


imagePullSecrets: [] 
nameOverride: "" 
fullnameOverride: "" 

 
serviceAccount: 

  # Specifies whether a service account should be created 

  create: false 

  # The name of the service account to use. 
  # If not set and create is true, a name is generated using the fullname template 

  name: 
 

podSecurityContext: 

  {} 

  # fsGroup: 2000 

 
securityContext: 

  {} 
  # capabilities: 
  #   drop: 
  #   - ALL 
  # readOnlyRootFilesystem: true 
  # runAsNonRoot: true 
  # runAsUser: 1000 

 
service: 

  type: ClusterIP 
  port: 80 

  
ingress: 

  enabled: false 
  annotations: 

    {} 

    # kubernetes.io/ingress.class: nginx 
    # kubernetes.io/tls-acme: "true" 

  hosts: 

    - host: chart-example.local 
      paths: [] 

  
  tls: [] 

  #  - secretName: chart-example-tls 
  #    hosts: 
  #      - chart-example.local 

 
resources: 

  {} 

  # We usually recommend not to specify default resources and to leave this as a conscious 
  # choice for the user. This also increases chances charts run on environments with little 
  # resources, such as Minikube. If you do want to specify resources, uncomment the following 
  # lines, adjust them as necessary, and remove the curly braces after 'resources:'. 
  # limits: 
  #   cpu: 100m 
  #   memory: 128Mi 
  # requests: 
  #   cpu: 100m 
  #   memory: 128Mi 
 

nodeSelector: {} 

 
tolerations: [] 

 
affinity: {}

Referências de porta: Esta porta encontra seu uso em vários locais:
- Dentro de service.yaml como {{ Values.service.port }}

Exemplo de arquivo service.yaml

apiVersion: v1 
kind: Service 

metadata: 
  name: {{ include "nginxdemo.fullname" . }} 
  labels: 

{{ include "nginxdemo.labels" . | indent 4 }} 

spec: 
  type: {{ .Values.service.type }} 
  ports: 
    - port: {{ .Values.service.port }} 
      targetPort: http 
      protocol: TCP 
      name: http 

  selector: 
    app.kubernetes.io/name: {{ include "nginxdemo.name" . }} 
    app.kubernetes.io/instance: {{ .Release.Name }}

Em nginx_config_map.yaml representado como {{ Values.service.port }}. Este arquivo corresponde a /etc/nginx/conf.d/default.conf, com um mapeamento estabelecido usando um mapa de configuração em deployment.yaml.

Exemplo de arquivo nginx_config_map.yaml

apiVersion: v1 
kind: ConfigMap 
metadata: 
  name: nginx-config 
# This writes the nginx config file to the ConfigMap and deployment.yaml mounts it as a volume  
# to the right place. 

data: 
  default.conf: | 
    log_format client '$remote_addr - $remote_user $request_time $upstream_response_time ' 
                    '[$time_local] "$request" $status $body_bytes_sent $request_body "$http_referer" ' 
                    '"$http_user_agent" "$http_x_forwarded_for"'; 

    server { 
        listen       80; 
        listen       {{ .Values.service.port }}; 
        listen  [::]:80; 
        server_name  localhost; 

        access_log  /var/log/nginx/host.access.log  client; 

        location / { 
            root   /usr/share/nginx/html; 
            index  index.html index.htm; 
            error_page 405 =200 $uri; 
        } 


        #error_page  404              /404.html; 
        # redirect server error pages to the static page /50x.html 
        # 
        error_page   500 502 503 504  /50x.html; 
        location = /50x.html { 
            root   /usr/share/nginx/html; 
        } 


        location = /cnf/test {   
            error_page 405 =200 $uri; 
        } 
   

        location = /post_thing { 
            # turn off logging here to avoid double logging 
            access_log off; 
            error_page 405 =200 $uri; 
        } 
    }

Configuração de implantação: o deployment.yaml arquivo mostra linhas específicas pertinentes a imagePullSecrets e image. Certifique-se de observar seu formato estruturado, pois o Azure Operator Service Manager (AOSM) fornece os valores necessários para esses campos durante a implantação. Para obter mais informações, consulte Requisitos do pacote Helm.

Exemplo de arquivo deployment.yaml

apiVersion: apps/v1 
kind: Deployment 
metadata: 
  name: {{ include "nginxdemo.fullname" . }} 
  labels: 
{{ include "nginxdemo.labels" . | indent 4 }} 

spec: 
  replicas: {{ .Values.replicaCount }} 
  selector: 
    matchLabels: 
      app.kubernetes.io/name: {{ include "nginxdemo.name" . }} 
      app.kubernetes.io/instance: {{ .Release.Name }} 

  template: 
    metadata: 
      labels: 
        app.kubernetes.io/name: {{ include "nginxdemo.name" . }} 
        app.kubernetes.io/instance: {{ .Release.Name }} 

    spec: 
      # Copied from sas 
      imagePullSecrets: {{ mustToPrettyJson (ternary (list ) .Values.imagePullSecrets (kindIs "invalid" .Values.imagePullSecrets)) }} 
      serviceAccountName: {{ template "nginxdemo.serviceAccountName" . }} 
      securityContext: 
        {{- toYaml .Values.podSecurityContext | nindent 8 }} 
      containers: 
        - name: {{ .Chart.Name }} 
          securityContext: 
            {{- toYaml .Values.securityContext | nindent 12 }} 
          # Want this to evaluate to acr-name.azurecr.io/nginx:stable (or specific version) 
          # docker tag nginx:stable acr-name.azurecr.io/nginx:stable 
          # docker push acr-name.azurecr.io/nginx:stable 
          # Image hard coded to that put in the Artifact Store ACR for this CNF POC 
          image: "{{ .Values.image.repository }}/nginx:stable" 
          imagePullPolicy: {{ .Values.image.pullPolicy }} 
          ports: 
            - name: http 
              containerPort: 80 
              protocol: TCP 
          livenessProbe: 
            httpGet: 
              path: / 
              port: http 
          readinessProbe: 
            httpGet: 
              path: / 
              port: http 
          resources: 
            {{- toYaml .Values.resources | nindent 12 }} 
          # Gets the nginx config from the configMap - see nginx_config_map.yaml 
          volumeMounts: 
            - name: nginx-config-volume 
              mountPath: /etc/nginx/conf.d/default.conf 
              subPath: default.conf 
      volumes: 
        - name: nginx-config-volume 
          configMap: 
            name: nginx-config 
      {{- with .Values.nodeSelector }} 
      nodeSelector: 
        {{- toYaml . | nindent 8 }} 
      {{- end }} 
    {{- with .Values.affinity }} 
      affinity: 
        {{- toYaml . | nindent 8 }} 
    {{- end }} 
    {{- with .Values.tolerations }} 
      tolerations: 
        {{- toYaml . | nindent 8 }} 
    {{- end }}

Próximos passos

Guia de início rápido: publicar o contêiner Nginx como função de rede conteinerizada (CNF)

Share via