Guida introduttiva: Completare i prerequisiti per distribuire una funzione di rete in contenitori in Azure Operator Service Manager

Articolo
11/08/2023

In questa guida introduttiva si completano le attività necessarie prima di usare Azure Operator Service Manager (AOSM).

Prerequisiti

Contattare il team dell'account Microsoft per registrare la sottoscrizione di Azure per l'accesso ad Azure Operator Service Manager (AOSM) o esprimere l'interesse tramite il modulo di registrazione del partner.

Scaricare e installare l'interfaccia della riga di comando di Azure

Usare l'ambiente Bash in Azure Cloud Shell. Per altre informazioni, vedere Avviare Cloud Shell per usare l'ambiente Bash in Azure Cloud Shell.

Per gli utenti che preferiscono eseguire i comandi di riferimento dell'interfaccia della riga di comando in locale, vedere Come installare l'interfaccia della riga di comando di Azure.

Se si esegue in Window o macOS, prendere in considerazione l'esecuzione dell'interfaccia della riga di comando di Azure in un contenitore Docker. Per altre informazioni, vedere Come eseguire l'interfaccia della riga di comando di Azure in un contenitore Docker.

Se si usa un'installazione locale, accedere all'interfaccia della riga di comando di Azure usando il az login comando e completare i prompt visualizzati nel terminale per completare l'autenticazione. Per altre opzioni di accesso, vedere Accedere con l'interfaccia della riga di comando di Azure.

Installare l'estensione dell'interfaccia della riga di comando di Azure Operator Service Manager (AOSM)

Installare l'estensione dell'interfaccia della riga di comando di Azure Operator Service Manager (AOSM) usando questo comando:

az extension add --name aosm

Eseguire az version per visualizzare la versione e le librerie dipendenti installate.
Eseguire az upgrade per eseguire l'aggiornamento alla versione corrente dell'interfaccia della riga di comando di Azure.

Registrare e verificare i provider di risorse necessari

Prima di iniziare a usare Azure Operator Service Manager, eseguire i comandi seguenti per registrare il provider di risorse richiesto. Questo processo di registrazione può richiedere fino a 5 minuti.

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

Verificare lo stato di registrazione dei provider di risorse. Eseguire i comandi seguenti.

# 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

Il completamento della registrazione del provider di risorse potrebbe richiedere alcuni minuti. Al termine della registrazione, è possibile procedere con l'uso di Azure Operator Service Manager (AOSM).

Requisiti per la funzione di rete in contenitori (CNF)

Per coloro che usano Funzioni di rete in contenitori, è essenziale assicurarsi che i pacchetti seguenti siano installati nel computer da cui si esegue l'interfaccia della riga di comando:

Installare Docker, vedere Installare il motore Docker.
Installare Helm, vedere Installare l'interfaccia della riga di comando helm.

Configurare la distribuzione della funzione di rete in contenitori

Per le distribuzioni di funzioni di rete in contenitori, è fondamentale archiviare quanto segue nel computer da cui si esegue l'interfaccia della riga di comando:

Pacchetti Helm con schema : questi pacchetti devono essere presenti nella risorsa di archiviazione locale e a cui si fa riferimento all'interno del input.json file di configurazione. Quando si segue questa guida introduttiva, scaricare il pacchetto Helm necessario.
Creazione di un file di configurazione di esempio: generare un file di configurazione di esempio per la definizione di una distribuzione CNF. Eseguire questo comando per generare un input.json file che è necessario popolare con la configurazione specifica.
```
az aosm nfd generate-config --definition-type cnf
```
Immagini per il CNF : ecco le opzioni seguenti:
- Riferimento a un Registro Azure Container esistente che contiene le immagini per il CNF. Attualmente, sono supportati un solo record di controllo di accesso e uno spazio dei nomi per CNF. Le immagini da copiare da questo Registro Azure Container vengono popolate automaticamente in base allo schema del pacchetto Helm. Per questo Registro Azure Container è necessario disporre delle autorizzazioni Reader/AcrPull. Per usare questa opzione, compilare source_registry e facoltativamente source_registry_namespace nel file input.json.
- Nome dell'immagine Docker di origine dal computer locale. Questo nome di immagine è per un caso d'uso limitato in cui il CNF richiede solo una singola immagine Docker esistente nel repository Docker locale. Per usare questa opzione, compilare source_local_docker_image il file input.json. Richiede l'installazione di Docker. Questa guida introduttiva illustra come scaricare un'immagine docker nginx da usare per questa opzione.
Facoltativo: file di mapping (path_to_mappings): facoltativamente, è possibile specificare un file (su disco) denominato path_to_mappings. Questo file deve eseguire il mirroring values.yamldi , con i valori selezionati sostituiti dai parametri di distribuzione. In questo modo vengono esposti come parametri al CNF. In alternativa, è possibile lasciare vuoto e input.json l'interfaccia della riga di comando genera il file. Per impostazione predefinita in questo caso, ogni valore all'interno values.yaml viene esposto come parametro di distribuzione. In alternativa, usare l'argomento dell'interfaccia della --interactive riga di comando per effettuare scelte in modo interattivo. Questa guida introduttiva illustra la creazione di questo file.

Quando si configura il input.json file, assicurarsi di elencare i pacchetti Helm nell'ordine in cui devono essere distribuiti. Ad esempio, se il pacchetto "A" deve essere distribuito prima del pacchetto "B", la input.json struttura dovrebbe essere simile alla seguente:

"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"
        ]
    }
]

Seguendo queste linee guida si garantisce un approccio ben organizzato e strutturato per distribuire funzioni di rete in contenitori con pacchetti Helm e configurazioni associate.

Scaricare l'immagine nginx nel repository Docker locale

Per questa guida introduttiva si scarica l'immagine docker nginx nel repository locale. L'estensione dell'interfaccia della riga di comando di Azure Operator Service Manager (AOSM) di Azure esegue il push dell'immagine da questa posizione all'archivio di elementi di Azure Operator Service Manager (AOSM). L'estensione dell'interfaccia della riga di comando supporta anche la copia dell'immagine da un Registro Azure Container esistente. La copia dell'immagine è il caso d'uso predefinito previsto, ma è più lenta per una guida introduttiva per creare un Registro Azure Container da copiare in modo che questo metodo non venga usato qui.

Eseguire il comando seguente: docker pull nginx:stable

Scaricare il grafico Helm di esempio

Scaricare il grafico Helm di esempio da qui Grafico Helm di esempio da usare con questa guida introduttiva.

Approfondire i grafici Helm

Questa sezione presenta un grafico Helm di base che configura nginx e lo configura per l'ascolto su una porta specificata. Il grafico Helm fornito in questa sezione incorpora già un values.schema.json file.

File values.schema.json di esempio

{
    "$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"
}

Sebbene questo articolo non esamini le complessità di Helm, alcuni elementi che vale la pena evidenziare includono:

Configurazione della porta del servizio: ha values.yaml un set di impostazioni con una porta del servizio pari a 80.

File values.yaml di esempio

# 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: {}

Riferimenti alle porte: questa porta trova l'uso in più posizioni:
- All'interno di service.yaml come {{ Values.service.port }}

File service.yaml di esempio

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 }}

In nginx_config_map.yaml rappresentato come {{ Values.service.port }}. Questo file corrisponde a /etc/nginx/conf.d/default.conf, con un mapping stabilito usando una mappa di configurazione in deployment.yaml.

File nginx_config_map.yaml di esempio

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; 
        } 
    }

Configurazione della distribuzione: il deployment.yaml file presenta righe specifiche pertinenti a imagePullSecrets e image. Assicurarsi di osservare il formato strutturato, perché Azure Operator Service Manager (AOSM) fornisce i valori necessari per questi campi durante la distribuzione. Per altre informazioni, vedere Requisiti dei pacchetti Helm.

File deployment.yaml di esempio

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 }}

Passaggi successivi

Guida introduttiva: Pubblicare un contenitore Nginx come funzione di rete in contenitori (CNF)

Share via