Snabbstart: Slutför kraven för att distribuera en containerbaserad nätverksfunktion i Azure Operator Service Manager

Artikel
11/08/2023

I den här snabbstarten slutför du de uppgifter som krävs innan du använder Azure Operator Service Manager (AOSM).

Förutsättningar

Kontakta ditt Microsoft-kontoteam för att registrera din Azure-prenumeration för åtkomst till Azure Operator Service Manager (AOSM) eller uttrycka ditt intresse via partnerregistreringsformuläret.

Ladda ned och installera Azure CLI

Använd Bash-miljön i Azure Cloud Shell. Mer information finns i Starta Cloud Shell för att använda Bash-miljön i Azure Cloud Shell.

Användare som föredrar att köra CLI-referenskommandon lokalt finns i Installera Azure CLI.

Om du kör windows eller macOS kan du överväga att köra Azure CLI i en Docker-container. Mer information finns i Så här kör du Azure CLI i en Docker-container.

Om du använder en lokal installation loggar du in på Azure CLI med kommandot az login och slutför anvisningarna som visas i terminalen för att slutföra autentiseringen. Fler inloggningsalternativ finns i Logga in med Azure CLI.

Installera CLI-tillägget för Azure Operator Service Manager (AOSM)

Installera CLI-tillägget för Azure Operator Service Manager (AOSM) med det här kommandot:

az extension add --name aosm

Kör az version för att se vilken version och beroende bibliotek som är installerade.
Kör az upgrade för att uppgradera till den aktuella versionen av Azure CLI.

Registrera och verifiera nödvändiga resursprovidrar

Innan du börjar använda Azure Operator Service Manager kör du följande kommandon för att registrera den nödvändiga resursprovidern. Den här registreringsprocessen kan ta upp till 5 minuter.

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

Verifiera resursprovidrars registreringsstatus. Kör följande kommandon.

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

Kommentar

Det kan ta några minuter innan registreringen av resursprovidern slutförs. När registreringen har slutförts kan du fortsätta med att använda Azure Operator Service Manager (AOSM).

Krav för containerbaserad nätverksfunktion (CNF)

För dem som använder Containerized Network Functions är det viktigt att se till att följande paket är installerade på den dator som du kör CLI från:

Installera docker, se Installera Docker-motorn.
Installera Helm, se Installera Helm CLI.

Konfigurera distribution av containerbaserad nätverksfunktion (CNF)

För distributioner av Containerized Network Functions (CNFs) är det viktigt att följande lagras på den dator som du kör CLI från:

Helm-paket med schema – Dessa paket bör finnas på din lokala lagring och refereras i konfigurationsfilen input.json . När du följer den här snabbstarten laddar du ned det nödvändiga helm-paketet.
Skapa en exempelkonfigurationsfil – Generera en exempelkonfigurationsfil för att definiera en CNF-distribution. Utfärda det här kommandot för att generera en input.json fil som du behöver fylla i med din specifika konfiguration.
```
az aosm nfd generate-config --definition-type cnf
```
Bilder för din CNF – Här är alternativen:
- En referens till ett befintligt Azure Container Registry som innehåller avbildningarna för din CNF. För närvarande stöds endast en ACR och ett namnområde per CNF. De avbildningar som ska kopieras från denna ACR fylls i automatiskt baserat på helm-paketschemat. Du måste ha behörigheter för läsare/AcrPull för den här ACR:en. Om du vill använda det här alternativet fyller du i source_registry och eventuellt source_registry_namespace i filen input.json.
- Avbildningsnamnet för käll docker-avbildningen från den lokala datorn. Det här avbildningsnamnet är för ett begränsat användningsfall där CNF endast kräver en enskild docker-avbildning som finns på den lokala Docker-lagringsplatsen. Om du vill använda det här alternativet fyller du i source_local_docker_image filen input.json. Kräver att docker installeras. Den här snabbstarten vägleder dig genom att ladda ned en nginx docker-avbildning som ska användas för det här alternativet.
Valfritt: Mappningsfil (path_to_mappings): Om du vill kan du ange en fil (på disk) med namnet path_to_mappings. Den här filen ska spegla values.yaml, med de valda värdena ersatta av distributionsparametrar. Om du gör det exponeras de som parametrar för CNF. Eller så kan du lämna detta tomt i input.json och CLI genererar filen. I det här fallet exponeras som standard varje värde inom values.yaml som en distributionsparameter. Du kan också använda CLI-argumentet --interactive för att göra val interaktivt. Den här snabbstarten vägleder dig genom att skapa den här filen.

När du konfigurerar input.json filen kontrollerar du att du listar Helm-paketen i den ordning de ska distribueras. Om till exempel paket "A" måste distribueras före paketet "B" bör du input.json likna följande struktur:

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

Genom att följa dessa riktlinjer säkerställer du en välorganiserad och strukturerad metod för att distribuera Containerized Network Functions (CNFs) med Helm-paket och associerade konfigurationer.

Ladda ned nginx-avbildning till lokal docker-lagringsplats

I den här snabbstarten laddar du ned nginx docker-avbildningen till din lokala lagringsplats. Azure Operator Service Manager(AOSM) Azure CLI-tillägget skickar avbildningen därifrån till Artefaktarkivet ACR för Azure Operator Service Manager (AOSM). CLI-tillägget stöder också kopiering av avbildningen från en befintlig ACR. Kopiering av avbildningen är det förväntade standardanvändningsfallet, men det går långsammare för en snabbstart att skapa en ACR att kopiera från så att den här metoden inte används här.

Utfärda följande kommando: docker pull nginx:stable

Ladda ned Helm-exempeldiagram

Ladda ned Helm-exempeldiagrammet härifrån Exempel på Helm-diagram för användning med den här snabbstarten.

Gå in på Helm-diagram

I det här avsnittet beskrivs ett grundläggande Helm-diagram som konfigurerar nginx och konfigurerar det för att lyssna på en angiven port. Helm-diagrammet som finns i det här avsnittet innehåller redan en values.schema.json fil.

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

Även om den här artikeln inte fördjupar sig i Helms invecklingar, är några element som är värda att markera:

Konfiguration av tjänstport:values.yaml Har en förinställning med en tjänstport på 80.

Exempelfilen values.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: {}

Portreferenser: Den här porten hittar dess användning på flera platser:
- Inom service.yaml som {{ Values.service.port }}

Exempelfil för 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 }}

I nginx_config_map.yaml representeras som {{ Values.service.port }}. Den här filen motsvarar , med en mappning upprättad med hjälp av en konfigurationskarta /etc/nginx/conf.d/default.confi deployment.yaml.

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

Distributionskonfiguration: Filen deployment.yaml visar specifika rader som är relevanta för imagePullSecrets och image. Observera deras strukturerade format eftersom Azure Operator Service Manager (AOSM) tillhandahåller nödvändiga värden för dessa fält under distributionen. Mer information finns i Krav för Helm-paket.

Exempel på deployment.yaml-fil

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

Nästa steg

Snabbstart: Publicera Nginx-container som containerbaserad nätverksfunktion (CNF)