Rychlý start: Dokončení požadavků pro nasazení kontejnerizované síťové funkce v Azure Operator Service Manageru

Článek
11/08/2023

V tomto rychlém startu dokončíte úlohy potřebné před použitím Azure Operator Service Manageru (AOSM).

Předpoklady

Obraťte se na tým účtu Microsoft a zaregistrujte své předplatné Azure pro přístup k Azure Operator Service Manageru (AOSM) nebo vyjádřit svůj zájem prostřednictvím registračního formuláře partnera.

Stažení a instalace Azure CLI

Použijte prostředí Bash v Azure Cloud Shellu. Další informace najdete v tématu Spuštění Cloud Shellu pro použití prostředí Bash v Azure Cloud Shellu.

Pro uživatele, kteří dávají přednost místnímu spouštění referenčních příkazů rozhraní příkazového řádku, se dozvíte, jak nainstalovat Azure CLI.

Pokud používáte Windows nebo macOS, zvažte spuštění Azure CLI v kontejneru Dockeru. Další informace najdete v tématu Jak spustit Azure CLI v kontejneru Dockeru.

Pokud používáte místní instalaci, přihlaste se k Azure CLI pomocí az login příkazu a dokončete výzvy zobrazené v terminálu a dokončete ověřování. Další možnosti přihlášení najdete v tématu Přihlášení pomocí Azure CLI.

Instalace rozšíření rozhraní příkazového řádku Azure Operator Service Manageru (AOSM)

Pomocí následujícího příkazu nainstalujte rozšíření Rozhraní příkazového řádku Azure Operator Service Manageru (AOSM):

az extension add --name aosm

Spuštěním zobrazíte az version nainstalované verze a závislé knihovny.
Spusťte az upgrade upgrade na aktuální verzi Azure CLI.

Registrace a ověření požadovaných poskytovatelů prostředků

Než začnete používat Azure Operator Service Manager, spusťte následující příkazy, které zaregistrují požadovaného poskytovatele prostředků. Tento proces registrace může trvat až 5 minut.

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

Ověřte stav registrace poskytovatelů prostředků. Spusťte následující příkazy.

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

Poznámka:

Dokončení registrace poskytovatele prostředků může trvat několik minut. Po úspěšném dokončení registrace můžete pokračovat pomocí Azure Operator Service Manageru (AOSM).

Požadavky na kontejnerizovanou síťovou funkci (CNF)

Pro ty, kteří využívají kontejnerizované síťové funkce, je nezbytné zajistit, aby se na počítači, ze kterého spouštíte rozhraní příkazového řádku, nainstalovaly následující balíčky:

Nainstalujte docker, přečtěte si informace o instalaci modulu Docker.
Nainstalujte Helm, přečtěte si informace o instalaci Rozhraní příkazového řádku Helm.

Konfigurace nasazení containerizované síťové funkce (CNF)

Pro nasazení containerizovaných síťových funkcí (CNF) je důležité mít na počítači, ze kterého spouštíte rozhraní příkazového řádku, uložená následující data:

Balíčky Helm se schématem – Tyto balíčky by se měly nacházet v místním úložišti a odkazovat na ho v rámci konfiguračního input.json souboru. Po provedení tohoto rychlého startu stáhnete požadovaný balíček Helm.
Vytvoření ukázkového konfiguračního souboru – Vygenerujte ukázkový konfigurační soubor pro definování nasazení CNF. Tento příkaz vygenerujte input.json soubor, který potřebujete naplnit konkrétní konfigurací.
```
az aosm nfd generate-config --definition-type cnf
```
Obrázky pro CNF – Tady jsou možnosti:
- Odkaz na existující službu Azure Container Registry, která obsahuje image pro váš CNF. V současné době se pro CNF podporuje pouze jeden obor názvů ACR a obor názvů. Image, které se mají zkopírovat z této služby ACR, se vyplní automaticky na základě schématu balíčku Helm. K této službě ACR musíte mít oprávnění Čtenář/AcrPull. Pokud chcete tuto možnost použít, vyplňte source_registry a volitelně source_registry_namespace do souboru input.json.
- Název image zdrojové image Dockeru z místního počítače. Tento název image je určený pro omezený případ použití, kdy CNF vyžaduje pouze jednu image Dockeru, která existuje v místním úložišti Dockeru. Pokud chcete tuto možnost použít, vyplňte source_local_docker_image soubor input.json. Vyžaduje instalaci Dockeru. Tento rychlý start vás provede stažením image dockeru nginx, která se má použít pro tuto možnost.
Volitelné: Soubor mapování (path_to_mappings): Volitelně můžete zadat soubor (na disku) s názvem path_to_mappings. Tento soubor by měl zrcadlit values.yamls vybranými hodnotami nahrazenými parametry nasazení. Tím je zpřístupníte jako parametry CNF. Nebo můžete nechat toto pole prázdné input.json a rozhraní příkazového řádku vygeneruje soubor. V tomto případě se každá hodnota v values.yaml tomto případě zobrazí jako parametr nasazení. Případně můžete použít argument rozhraní příkazového --interactive řádku k interaktivnímu výběru. Tento rychlý start vás provede vytvořením tohoto souboru.

Při konfiguraci input.json souboru se ujistěte, že vypíšete balíčky Helm v pořadí, v jakém se mají nasadit. Pokud například musí být balíček "A" nasazen před balíčkem "B" input.json , měla by vypadat nějak takto:

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

Podle těchto pokynů zajistíte dobře uspořádaný a strukturovaný přístup k nasazení containerizovaných síťových funkcí (CNF) s balíčky Helm a přidruženými konfiguracemi.

Stažení image nginx do místního úložiště Dockeru

Pro účely tohoto rychlého startu stáhnete image dockeru nginx do místního úložiště. Rozšíření Azure CLI pro operátora Azure (AOSM) nasdílí image z něj do ACR úložiště artefaktů Azure Operator Service Manageru (AOSM). Rozšíření rozhraní příkazového řádku také podporuje kopírování image z existující služby ACR. Kopírování image je očekávaným výchozím případem použití, ale rychlé zprovoznění je pomalejší, když chcete vytvořit ACR pro kopírování, aby se tato metoda zde nepoužívala.

Zadejte následující příkaz: docker pull nginx:stable

Stažení ukázkového chartu Helm

Stáhněte si z tohoto příkladu ukázkový chart Helm pro použití s tímto rychlým startem.

Ponořte se do chartů Helm

Tato část vás seznámí se základním grafem Helm, který nastaví nginx a nakonfiguruje ho tak, aby naslouchal na zadaném portu. Chart Helm zařízený v této části už obsahuje values.schema.json soubor.

Ukázkový soubor 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"
}

I když se tento článek nezabývá do složitých prvků Helmu, několik prvků, které stojí za zvýraznění, patří:

Konfigurace portu služby: Má values.yaml přednastavený port služby 80.

Ukázkový soubor 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: {}

Odkazy na porty: Tento port najde své použití v několika umístěních:
- Uvnitř service.yaml jako {{ Values.service.port }}

Ukázkový soubor 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 }}

Reprezentováno nginx_config_map.yaml jako {{ Values.service.port }}. Tento soubor odpovídá /etc/nginx/conf.d/default.conf, s mapováním vytvořeným pomocí konfigurační mapy v deployment.yamlsouboru .

Ukázkový soubor 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; 
        } 
    }

Konfigurace nasazení: Soubor deployment.yaml předvádí konkrétní řádky, které imagePullSecrets se týkají a image. Nezapomeňte sledovat jejich strukturovaný formát, protože Azure Operator Service Manager (AOSM) poskytuje potřebné hodnoty pro tato pole během nasazování. Další informace najdete v tématu Požadavky na balíček Helm.

Ukázkový soubor 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 }}

Další kroky

Rychlý start: Publikování kontejneru Nginx jako kontejnerizované síťové funkce (CNF)