Inicio rápido: Completar los requisitos previos para implementar una función de red en contenedor en Azure Operator Service Manager

Artículo
11/18/2023

En este Inicio rápido, completará las tareas necesarias previas para usar Azure Operator Service Manager (AOSM).

Requisitos previos

Póngase en contacto con el equipo de la cuenta Microsoft para registrar su suscripción de Azure para acceder a Azure Operator Service Manager (AOSM) o exprese su interés mediante el formulario de registro de asociados.

Descarga e instalación de la CLI de Azure

Use el entorno de Bash en Azure Cloud Shell. Para obtener más información, consulte Inicio de Cloud Shell para usar el entorno de Bash en Azure Cloud Shell.

Para los usuarios que prefieran ejecutar comandos de referencia de la CLI localmente, consulte Instalación de la CLI de Azure.

Si utiliza Windows o macOS, considere la posibilidad de ejecutar la CLI de Azure en un contenedor Docker. Para más información, vea Ejecución de la CLI de Azure en un contenedor de Docker.

Si usa una instalación local, inicie sesión en la CLI de Azure mediante el comando az login y complete las indicaciones que se muestran en el terminal para finalizar la autenticación. Para ver más opciones de inicio de sesión, consulte Inicio de sesión con la CLI de Azure.

Instalación de la extensión de la CLI de Azure Operator Service Manager (AOSM)

Instale la extensión de la CLI de Azure Operator Service Manager (AOSM) mediante este comando:

az extension add --name aosm

Ejecute az version para ver la versión y las bibliotecas dependientes que están instaladas.
Ejecute az upgrade para actualizar a la versión actual de la CLI de Azure.

Registro y comprobación de los proveedores de recursos necesarios

Antes de empezar a usar Azure Operator Service Manager, ejecute los siguientes comandos para registrar el proveedor de recursos necesario. El proceso de registro puede tardar hasta 5 minutos.

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

Compruebe el estado de registro de los proveedores de recursos. Ejecute los siguientes comandos.

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

El registro del proveedor de recursos puede tardar unos minutos en completarse. Una vez que el registro se realice correctamente, puede continuar con el uso de Azure Operator Service Manager (AOSM).

Requisitos de la función de red en contenedor (CNF)

Para aquellos que usan funciones de red en contenedores, es esencial asegurarse de que los siguientes paquetes estén instalados en la máquina desde la que se ejecuta la CLI:

Para la instalación de Docker, consulte Instalación del motor de Docker.
Para la instalación de Helm, consulte Instalación de la CLI de Helm.

Configuración de la implementación de la función de red en contenedor (CNF)

En el caso de las implementaciones de funciones de red en contenedor (CNF), es fundamental tener lo siguiente almacenado en la máquina desde la que está ejecutando la CLI:

Paquetes de Helm con esquema: estos paquetes deben estar presentes en el almacenamiento local y se debe hacer referencia a ellos en el archivo de configuración input.json. Al seguir este inicio rápido, descargará el paquete de Helm necesario.
Creación de un archivo de configuración de ejemplo: genere un archivo de configuración de ejemplo para definir una implementación de CNF. Emita este comando para generar un archivo input.json que debe rellenar con la configuración específica.
```
az aosm nfd generate-config --definition-type cnf
```
Imágenes para la CNF: estas son las opciones:
- Referencia a una instancia de Azure Container Registry existente que contiene las imágenes de la CNF. Actualmente, solo se admite una instancia de ACR y un espacio de nombres por cada CNF. Las imágenes que se van a copiar de esta instancia de ACR se rellenan automáticamente en función del esquema del paquete de Helm. Debe tener permisos de lector/AcrPull en esta instancia de ACR. Para usar esta opción, rellene source_registry y, opcionalmente, source_registry_namespace en el archivo input.json.
- Nombre de la imagen de Docker de origen de la máquina local. Este nombre de imagen es para un caso de uso limitado en el que la CNF solo requiere una sola imagen de Docker que existe en el repositorio de Docker local. Para usar esta opción, rellene source_local_docker_image en el archivo input.json. Requiere que Docker esté instalado. Este inicio rápido le guía en la descarga de una imagen de Docker de nginx para usarla para esta opción.
Opcional: archivo de asignación (path_to_mappings): opcionalmente, puede proporcionar un archivo (en disco) llamado path_to_mappings. Este archivo debe reflejar values.yaml, con los valores seleccionados reemplazados por parámetros de implementación. Al hacerlo, los expone como parámetros a la CNF. O bien, puede dejar este valor en blanco en el archivo input.json y la CLI genera el archivo. De manera predeterminada, en este caso, se expone como parámetro de implementación cada valor de values.yaml. También puede usar el argumento --interactive de la CLI de para tomar decisiones de forma interactiva. Este inicio rápido le guía en la creación de este archivo.

Al configurar el archivo input.json, asegúrese de enumerar los paquetes de Helm en el orden en el que se deben implementar. Por ejemplo, si el paquete "A" se debe implementar antes que el paquete "B", el archivo input.json debe ser similar a la estructura siguiente:

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

Siguiendo estas instrucciones, se garantiza un enfoque bien organizado y estructurado para implementar funciones de red en contenedor (CNF) con los paquetes de Helm y las configuraciones asociadas.

Descarga de la imagen de nginx en el repositorio de Docker local

Para este inicio rápido, descargará la imagen de Docker de nginx en el repositorio local. La extensión de la CLI de Azure Operator Service Manager (AOSM) inserta la imagen desde allí en la instancia de ACR del almacén de artefactos de Azure Operator Service Manager (AOSM). La extensión de la CLI también admite la copia de la imagen desde una instancia de ACR existente. Copiar la imagen es el caso de uso predeterminado esperado, pero es más lento en el caso de un inicio rápido crear una instancia de ACR desde la que copiarla, por lo que este método no se usa aquí.

Emita el comando siguiente: docker pull nginx:stable

Descarga del gráfico de Helm de ejemplo

Descargue el gráfico de Helm de ejemplo desde aquí: gráfico de Helm de ejemplo para usarlo con este inicio rápido.

Examen en profundidad de los gráficos de Helm

En esta sección, se presenta un gráfico básico de Helm que configura nginx y lo configura para escuchar en un puerto especificado. El gráfico de Helm proporcionado en esta sección ya incorpora un archivo values.schema.json.

Archivo values.schema.json de ejemplo

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

Aunque este artículo no profundiza en las complejidades de Helm, algunos elementos que merece la pena resaltar son:

Configuración del puerto de servicio: el archivo values.yaml tiene un valor preestablecido para el puerto de servicio de 80.

Archivo values.yaml de ejemplo

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

Referencias de puerto: este puerto busca su uso en varias ubicaciones:
- Dentro de service.yaml como {{ Values.service.port }}

Archivo service.yaml de ejemplo

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

En el archivo nginx_config_map.yaml, se representa como {{ Values.service.port }}. Este archivo corresponde a /etc/nginx/conf.d/default.conf, con una asignación establecida mediante un mapa de configuración en deployment.yaml.

Archivo nginx_config_map.yaml de ejemplo

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

Configuración de implementación: el archivo deployment.yaml muestra las líneas específicas correspondientes a imagePullSecrets y image. Asegúrese de observar su formato estructurado, ya que Azure Operator Service Manager (AOSM) proporciona los valores necesarios para estos campos durante la implementación. Para obtener más información, consulte Requisitos del paquete de Helm.

Archivo deployment.yaml de ejemplo

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

Pasos siguientes

Inicio rápido: Publicación de un contenedor de nginx como función de red en contenedor (CNF)

Share via