Szybki start: wykonywanie wymagań wstępnych dotyczących wdrażania konteneryzowanej funkcji sieciowej w programie Azure Operator Service Manager

W tym przewodniku Szybki start wykonasz zadania niezbędne przed użyciem programu Azure Operator Service Manager (AOSM).

Wymagania wstępne

Skontaktuj się z zespołem ds. kont Microsoft, aby zarejestrować subskrypcję platformy Azure w celu uzyskania dostępu do programu Azure Operator Service Manager (AOSM) lub wyrazić zainteresowanie za pośrednictwem formularza rejestracji partnera.

Pobieranie i instalowanie interfejsu wiersza polecenia platformy Azure

Użyj środowiska powłoki Bash w usłudze Azure Cloud Shell. Aby uzyskać więcej informacji, zobacz Uruchamianie usługi Cloud Shell w celu korzystania ze środowiska powłoki Bash w usłudze Azure Cloud Shell.

W przypadku użytkowników, którzy wolą uruchamiać polecenia referencyjne interfejsu wiersza polecenia lokalnie, zobacz Jak zainstalować interfejs wiersza polecenia platformy Azure.

Jeśli korzystasz z okna lub systemu macOS, rozważ uruchomienie interfejsu wiersza polecenia platformy Azure w kontenerze platformy Docker. Aby uzyskać więcej informacji, zobacz Jak uruchomić interfejs wiersza polecenia platformy Azure w kontenerze platformy Docker.

Jeśli używasz instalacji lokalnej, zaloguj się do interfejsu wiersza polecenia platformy Azure przy użyciu az login polecenia i ukończ monity wyświetlane w terminalu, aby zakończyć uwierzytelnianie. Aby uzyskać więcej opcji logowania, zobacz Logowanie się przy użyciu interfejsu wiersza polecenia platformy Azure.

Instalowanie rozszerzenia interfejsu wiersza polecenia programu Azure Operator Service Manager (AOSM)

Zainstaluj rozszerzenie interfejsu wiersza polecenia programu Azure Operator Service Manager (AOSM) przy użyciu tego polecenia:

az extension add --name aosm

1. Uruchom polecenie az version , aby wyświetlić zainstalowaną wersję i biblioteki zależne.
2. Uruchom polecenie az upgrade , aby uaktualnić do bieżącej wersji interfejsu wiersza polecenia platformy Azure.

Rejestrowanie i weryfikowanie wymaganych dostawców zasobów

Przed rozpoczęciem korzystania z programu Azure Operator Service Manager wykonaj następujące polecenia, aby zarejestrować wymaganego dostawcę zasobów. Ten proces rejestracji może potrwać do 5 minut.

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

Sprawdź stan rejestracji dostawców zasobów. Wykonaj następujące polecenia.

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

Uwaga

Ukończenie rejestracji dostawcy zasobów może potrwać kilka minut. Po pomyślnym zakończeniu rejestracji możesz kontynuować korzystanie z programu Azure Operator Service Manager (AOSM).

Wymagania dotyczące konteneryzowanej funkcji sieciowej (CNF)

W przypadku osób korzystających z konteneryzowanych funkcji sieciowych niezbędne jest upewnienie się, że na maszynie, na której jest wykonywany interfejs wiersza polecenia, są zainstalowane następujące pakiety:

• Zainstaluj platformę Docker, zobacz Instalowanie aparatu platformy Docker.
• Zainstaluj program Helm, zobacz Instalowanie interfejsu wiersza polecenia programu Helm.

Konfigurowanie wdrożenia funkcji sieci konteneryzowanej (CNF)

W przypadku wdrożeń konteneryzowanych funkcji sieciowych (CNFs) kluczowe jest przechowywanie następujących elementów na maszynie, z której jest wykonywany interfejs wiersza polecenia:

• Pakiety Helm ze schematem — te pakiety powinny znajdować się w magazynie lokalnym i przywoływne w input.json pliku konfiguracji. Korzystając z tego przewodnika Szybki start, pobierz wymagany pakiet helm.

• Tworzenie przykładowego pliku konfiguracji — generowanie przykładowego pliku konfiguracji do definiowania wdrożenia systemu CNF. Wydaj to polecenie, aby wygenerować input.json plik, który należy wypełnić za pomocą określonej konfiguracji.

  az aosm nfd generate-config --definition-type cnf
  

• Obrazy dla systemu CNF — oto opcje:

  • Odwołanie do istniejącej usługi Azure Container Registry zawierającej obrazy dla systemu CNF. Obecnie tylko jeden rekord ACR i przestrzeń nazw są obsługiwane dla systemu plików CNF. Obrazy, które mają być kopiowane z tego usługi ACR, są wypełniane automatycznie na podstawie schematu pakietu helm. Musisz mieć uprawnienia Czytelnik/AcrPull dla tego usługi ACR. Aby użyć tej opcji, wypełnij source_registry i opcjonalnie source_registry_namespace w pliku input.json.
  • Nazwa obrazu źródłowego obrazu platformy Docker z komputera lokalnego. Ta nazwa obrazu dotyczy ograniczonego przypadku użycia, w którym system plików CNF wymaga tylko jednego obrazu platformy Docker, który istnieje w lokalnym repozytorium platformy Docker. Aby użyć tej opcji, wypełnij source_local_docker_image plik input.json. Wymaga zainstalowania platformy Docker. Ten przewodnik Szybki start przeprowadzi Cię przez proces pobierania obrazu platformy Docker nginx do użycia dla tej opcji.

• Opcjonalnie: Plik mapowania (path_to_mappings): opcjonalnie możesz podać plik (na dysku) o nazwie path_to_mappings. Ten plik powinien dublować values.yamlelement z wybranymi wartościami zastąpionymi parametrami wdrożenia. W ten sposób uwidacznia je jako parametry dla systemu CNF. Możesz również pozostawić to pole puste w input.json pliku i wygenerować plik za pomocą interfejsu wiersza polecenia. Domyślnie każda wartość w tym values.yaml przypadku jest uwidoczniona jako parametr wdrożenia. Alternatywnie użyj argumentu interfejsu --interactive wiersza polecenia, aby interaktywnie dokonać wyborów. Ten przewodnik Szybki start przeprowadzi Cię przez proces tworzenia tego pliku.

Podczas konfigurowania input.json pliku upewnij się, że masz listę pakietów Helm w kolejności ich wdrożenia. Jeśli na przykład pakiet "A" musi zostać wdrożony przed pakietem "B" input.json , powinien on przypominać następującą 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"
        ]
    }
]

Przestrzeganie tych wytycznych zapewnia dobrze zorganizowane i ustrukturyzowane podejście do wdrażania konteneryzowanych funkcji sieciowych (CNFs) przy użyciu pakietów Helm i skojarzonych konfiguracji.

Pobieranie obrazu nginx do lokalnego repozytorium platformy Docker

Na potrzeby tego przewodnika Szybki start pobierzesz obraz platformy docker nginx do repozytorium lokalnego. Rozszerzenie interfejsu wiersza polecenia platformy Azure programu Azure Operator Service Manager (AOSM) wypycha obraz stamtąd do usługi ACR magazynu artefaktów programu Azure Operator Service Manager (AOSM). Rozszerzenie interfejsu wiersza polecenia obsługuje również kopiowanie obrazu z istniejącego usługi ACR. Kopiowanie obrazu jest oczekiwanym domyślnym przypadkiem użycia, ale jest wolniejsze, aby utworzyć rekord ACR do skopiowania, aby ta metoda nie była używana w tym miejscu.

Wydaj następujące polecenie: docker pull nginx:stable

Pobieranie przykładowego wykresu programu Helm

Pobierz przykładowy wykres helm z tego przewodnika Szybki start, aby użyć przykładowego wykresu helm.

Omówienie wykresów programu Helm

W tej sekcji przedstawiono podstawowy wykres helm, który konfiguruje serwer nginx i konfiguruje go do nasłuchiwania na określonym porcie. Wykres helm dostarczony w tej sekcji zawiera values.schema.json już plik.

Przykładowy plik 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"
}

Chociaż ten artykuł nie zagłębia się w zawiłości programu Helm, warto wyróżnić kilka elementów:

• Konfiguracja portu usługi: element values.yaml ma ustawienie wstępne z portem usługi 80.

Przykładowy plik 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: {}

• Odwołania do portów: ten port znajduje jego użycie w wielu lokalizacjach:

  • W ramach service.yaml{{ Values.service.port }}

Przykładowy plik 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 }}

• W elemecie nginx_config_map.yaml reprezentowanym jako {{ Values.service.port }}. Ten plik odpowiada metodzie /etc/nginx/conf.d/default.confz mapowaniem utworzonym przy użyciu mapy konfiguracji w programie deployment.yaml.

Przykładowy plik 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; 
        } 
    }

Konfiguracja wdrożenia:deployment.yaml plik przedstawia konkretne wiersze istotne dla imagePullSecrets i image. Pamiętaj, aby obserwować ich format ustrukturyzowany, ponieważ program Azure Operator Service Manager (AOSM) dostarcza niezbędne wartości dla tych pól podczas wdrażania. Aby uzyskać więcej informacji, zobacz Wymagania dotyczące pakietu Helm.

Przykładowy plik 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 }}

Następne kroki

• Szybki start: publikowanie kontenera Nginx jako konteneryzowanej funkcji sieciowej (CNF)