Rövid útmutató: A tárolóalapú hálózati függvény üzembe helyezésének előfeltételeinek teljesítése az Azure Operator Service Managerben

Cikk
11/08/2023

Ebben a rövid útmutatóban elvégezheti az Azure Operator Service Manager (AOSM) használata előtt szükséges feladatokat.

Előfeltételek

Lépjen kapcsolatba a Microsoft-fiók csapatával, és regisztrálja Azure-előfizetését az Azure Operator Service Managerhez (AOSM) való hozzáféréshez, vagy fejezze ki érdeklődését a partnerregisztrációs űrlapon keresztül.

Az Azure CLI letöltése és telepítése

Használja a Bash-környezetet az Azure Cloud Shellben. További információ: A Cloud Shell indítása Bash-környezet azure Cloud Shellben való használatához.

Azok a felhasználók, akik helyileg szeretnék futtatni a parancssori felületre vonatkozó referenciaparancsokat, tekintse meg az Azure CLI telepítésének módját.

Ha Windows vagy macOS rendszeren fut, fontolja meg az Azure CLI docker-tárolóban való futtatását. További információ: Az Azure CLI futtatása Docker-tárolóban.

Ha helyi telepítést használ, jelentkezzen be az Azure CLI-be a az login paranccsal, és fejezze be a terminálon megjelenő utasításokat a hitelesítés befejezéséhez. További bejelentkezési lehetőségekért tekintse meg az Azure CLI-vel való bejelentkezést.

Az Azure Operator Service Manager (AOSM) CLI-bővítmény telepítése

Telepítse az Azure Operator Service Manager (AOSM) CLI-bővítményt a következő paranccsal:

az extension add --name aosm

Futtassa az version a telepített verziókat és függő kódtárakat.
Futtassa az upgrade a frissítést az Azure CLI aktuális verziójára.

Szükséges erőforrás-szolgáltatók regisztrálása és ellenőrzése

Mielőtt elkezdené használni az Azure Operator Service Managert, hajtsa végre a következő parancsokat a szükséges erőforrás-szolgáltató regisztrálásához. Ez a regisztrációs folyamat akár 5 percet is igénybe vehet.

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

Ellenőrizze az erőforrás-szolgáltatók regisztrációs állapotát. Hajtsa végre a következő parancsokat.

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

Megjegyzés:

Eltarthat néhány percig, amíg az erőforrás-szolgáltató regisztrációja befejeződik. A regisztráció sikeres befejezése után folytathatja az Azure Operator Service Manager (AOSM) használatát.

A tárolóalapú hálózati függvényre (CNF) vonatkozó követelmények

A tárolóalapú hálózati függvényeket használó felhasználók számára elengedhetetlen annak biztosítása, hogy a következő csomagok legyenek telepítve azon a gépen, amelyről a parancssori felületet futtatja:

Telepítse a Dockert, tekintse meg a Docker-motor telepítését.
Telepítse a Helmt, tekintse meg a Helm parancssori felületének telepítését.

Tárolóalapú hálózati függvény (CNF) üzembe helyezésének konfigurálása

A tárolóalapú hálózati függvények (CNF-ek) központi telepítéseihez elengedhetetlen, hogy a következőt tárolja azon a gépen, amelyről a parancssori felületet futtatja:

Helm-csomagok sémával – Ezeknek a csomagoknak a helyi tárolóban kell lenniük, és a input.json konfigurációs fájlban kell hivatkozni gombra. A rövid útmutató követéséhez töltse le a szükséges helm-csomagot.
Mintakonfigurációs fájl létrehozása – Példakonfigurációs fájl létrehozása CNF-üzemelő példány meghatározásához. Adja ki ezt a parancsot egy input.json olyan fájl létrehozásához, amelyet fel kell töltenie az adott konfigurációval.
```
az aosm nfd generate-config --definition-type cnf
```
Képek a CNF-hez – A lehetőségek a következők:
- Hivatkozás egy meglévő Azure Container Registryre, amely a CNF rendszerképeit tartalmazza. CnF-enként jelenleg csak egy ACR és névtér támogatott. Az ebből az ACR-ből másolandó képek automatikusan ki lesznek töltve a helm-csomag sémája alapján. Ehhez az ACR-hez olvasói/AcrPull-engedélyekkel kell rendelkeznie. A beállítás használatához töltse ki source_registry és opcionálisan source_registry_namespace az input.json fájlt.
- A forrás Docker-rendszerkép képe a helyi gépről. Ez a képnév egy korlátozott használati esethez tartozik, ahol a CNF csak egyetlen docker-lemezképet igényel, amely a helyi Docker-adattárban található. A beállítás használatához töltse ki source_local_docker_image az input.json fájlt. A Docker telepítését igényli. Ez a rövid útmutató végigvezeti egy nginx docker-rendszerkép letöltésén, amelyet ehhez a beállításhoz használhat.
Nem kötelező: Leképezési fájl (path_to_mappings): Igény szerint megadhat egy path_to_mappings nevű fájlt (lemezen). Ennek a fájlnak tükröznie values.yamlkell a kiválasztott értékeket az üzembehelyezési paraméterekkel. Ezzel paraméterekként teszi elérhetővé őket a CNF számára. Vagy ezt üresen input.json hagyhatja, és a parancssori felület létrehozza a fájlt. Ebben az esetben alapértelmezés szerint minden érték values.yaml üzembehelyezési paraméterként jelenik meg. Másik lehetőségként a --interactive CLI argumentum használatával interaktívan hozhat döntéseket. Ez a rövid útmutató végigvezeti a fájl létrehozásának folyamatán.

A fájl konfigurálásakor input.json győződjön meg arról, hogy a Helm-csomagokat az üzembe helyezésük sorrendjében sorolja fel. Ha például az "A" csomagot a "B" csomag előtt kell üzembe helyezni, a input.json következő struktúrához kell hasonlítania:

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

Ezeknek az irányelveknek a betartása biztosítja a Tárolóalapú hálózati függvények (CNF-ek) Helm-csomagokkal és a hozzájuk tartozó konfigurációkkal való üzembe helyezésének jól szervezett és strukturált megközelítését.

Nginx-rendszerkép letöltése a helyi Docker-adattárba

Ebben a rövid útmutatóban letölti az nginx docker-rendszerképet a helyi adattárba. Az Azure Operator Service Manager (AOSM) Azure CLI-bővítmény innen küldi le a rendszerképet az Azure Operator Service Manager (AOSM) Artifact Store ACR-be. A CLI-bővítmény azt is támogatja, hogy a rendszerképet egy meglévő ACR-ből másolja. A rendszerkép másolása a várt alapértelmezett használati eset, de egy rövid útmutató lassabban hoz létre egy ACR-t a másoláshoz, hogy ez a módszer ne legyen itt használva.

Adja ki a következő parancsot: docker pull nginx:stable

Minta Helm-diagram letöltése

Töltse le innen a Helm-mintadiagramot a minta Helm-diagramból , és használja ezt a rövid útmutatót.

A Helm-diagramok bemutatása

Ez a szakasz egy alapszintű Helm-diagramot mutat be, amely beállítja az nginxet, és konfigurálja egy adott port figyelésére. Az ebben a szakaszban ismertetett Helm-diagram már tartalmaz egy values.schema.json fájlt.

Sample values.schema.json fájl

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

Bár ez a cikk nem ássa bele a Helm bonyolultságába, néhány kiemelendő elem:

Szolgáltatásport konfigurációja: A values.yaml szolgáltatás rendelkezik egy előre beállított, 80-at tartalmazó szolgáltatásporttal.

Minta values.yaml fájl

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

Porthivatkozások: Ez a port több helyen is megtalálja a használatát:
- Belül service.yaml , mint {{ Values.service.port }}

Sample service.yaml fájl

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

A nginx_config_map.yaml következőként ábrázolva: {{ Values.service.port }}. Ez a fájl megfelel a konfigurációs /etc/nginx/conf.d/default.confleképezéssel létrehozott leképezésnek a következőben deployment.yaml: .

Minta nginx_config_map.yaml-fájl

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

Üzembehelyezési konfiguráció: A deployment.yaml fájl a megfelelő és imageahhoz imagePullSecrets kapcsolódó konkrét sorokat mutatja be. Ügyeljen arra, hogy megfigyelje a strukturált formátumukat, mivel az Azure Operator Service Manager (AOSM) az üzembe helyezés során biztosítja ezeknek a mezőknek a szükséges értékeit. További információ: Helm-csomagkövetelmények.

Minta deployment.yaml fájl

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

Következő lépések

Rövid útmutató: Nginx-tároló közzététele tárolóalapú hálózati függvényként (CNF)

Share via