Hosting multisito con Gateway applicativo per contenitori - API in ingresso (anteprima)

Questo documento consente di configurare un'applicazione di esempio che usa le risorse dell'API in ingresso per illustrare come ospitare più siti nella stessa risorsa in ingresso Kubernetes/Gateway applicativo per contenitori front-end. Vengono forniti i passaggi per:

• Creare una risorsa in ingresso con due host.

Background

Il Gateway applicativo per contenitori consente l'hosting multi-sito, rendendo possibile la configurazione di più di un'applicazione Web nella stessa porta. Due o più siti univoci possono essere ospitati usando servizi back-end univoci. Vedere lo scenario di esempio seguente:

Prerequisiti

Importante

Il Gateway applicativo per contenitori è attualmente disponibile in ANTEPRIMA.
Vedere le condizioni per l'utilizzo supplementari per le anteprime di Microsoft Azure per termini legali aggiuntivi che si applicano a funzionalità di Azure in versione beta, in anteprima o in altro modo non ancora disponibili a livello generale.

1. Se si segue la strategia di distribuzione personalizzata BYO (Bring Your Own Deployment), assicurarsi di configurare le risorse del Gateway applicativo per contenitori e il controller ALB
2. Se si segue la strategia di distribuzione gestita di ALB, assicurarsi di effettuare il provisioning del controller ALB e delle risorse del Gateway applicativo per contenitori tramite la risorsa personalizzata ApplicationLoadBalancer.
3. Per distribuire l'applicazione di esempio HTTP, applicare il file deployment.yaml seguente nel cluster in modo da creare un'applicazione Web di esempio per illustrare il percorso, la query e il routing basato sull'intestazione.

kubectl apply -f https://trafficcontrollerdocs.blob.core.windows.net/examples/traffic-split-scenario/deployment.yaml

Questo comando crea quanto segue nel cluster:

• uno spazio dei nomi denominato test-infra
• due servizi denominati backend-v1 e backend-v2 nello spazio dei nomi test-infra
• due distribuzioni denominate backend-v1 e backend-v2 nello spazio dei nomi test-infra

Distribuire la risorsa in ingresso obbligatoria

Distribuzione gestita di ALB

1. Creare un ingresso

kubectl apply -f - <<EOF
apiVersion: networking.k8s.io/v1
kind: Ingress
metadata:
  name: ingress-01
  namespace: test-infra
  annotations:
    alb.networking.azure.io/alb-name: alb-test
    alb.networking.azure.io/alb-namespace: alb-test-infra
spec:
  ingressClassName: azure-alb-external
  rules:
    - host: contoso.com
      http:
        paths:
          - path: /
            pathType: Prefix
            backend:
              service:
                name: backend-v1
                port:
                  number: 8080
    - host: fabrikam.com
      http:
        paths:
          - path: /
            pathType: Prefix
            backend:
              service:
                name: backend-v2
                port:
                  number: 8080
EOF

Distribuzione Bring Your Own (BYO)

1. Impostare le variabili di ambiente seguenti

RESOURCE_GROUP='<resource group name of the Application Gateway For Containers resource>'
RESOURCE_NAME='alb-test'

RESOURCE_ID=$(az network alb show --resource-group $RESOURCE_GROUP --name $RESOURCE_NAME --query id -o tsv)
FRONTEND_NAME='frontend'

2. Creare un ingresso

kubectl apply -f - <<EOF
apiVersion: networking.k8s.io/v1
kind: Ingress
metadata:
  name: ingress-01
  namespace: test-infra
  annotations:
    alb.networking.azure.io/alb-id: $RESOURCE_ID
    alb.networking.azure.io/alb-frontend: $FRONTEND_NAME
spec:
  ingressClassName: azure-alb-external
  rules:
    - host: contoso.com
      http:
        paths:
          - path: /
            pathType: Prefix
            backend:
              service:
                name: backend-v1
                port:
                  number: 8080
    - host: fabrikam.com
      http:
        paths:
          - path: /
            pathType: Prefix
            backend:
              service:
                name: backend-v2
                port:
                  number: 8080
EOF

Dopo aver creato la risorsa in ingresso, verificare che lo stato mostri il nome host del servizio di bilanciamento del carico e che entrambe le porte siano in ascolto delle richieste.

kubectl get ingress ingress-01 -n test-infra -o yaml

Output di esempio della creazione corretta della risorsa in ingresso.

apiVersion: networking.k8s.io/v1
kind: Ingress
metadata:
  annotations:
    alb.networking.azure.io/alb-frontend: FRONTEND_NAME
    alb.networking.azure.io/alb-id: /subscriptions/xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx/resourcegroups/yyyyyyyy/providers/Microsoft.ServiceNetworking/trafficControllers/zzzzzz
    kubectl.kubernetes.io/last-applied-configuration: |
      {"apiVersion":"networking.k8s.io/v1","kind":"Ingress","metadata":{"annotations":{"alb.networking.azure.io/alb-frontend":"FRONTEND_NAME","alb.networking.azure.io/alb-id":"/subscriptions/xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx/resourcegroups/yyyyyyyy/providers/Microsoft.ServiceNetworking/trafficControllers/zzzzzz"},"name"
:"ingress-01","namespace":"test-infra"},"spec":{"ingressClassName":"azure-alb-external","rules":[{"host":"example.com","http":{"paths":[{"backend":{"service":{"name":"echo","port":{"number":80}}},"path":"/","pathType":"Prefix"}]}}],"tls":[{"hosts":["example.com"],"secretName":"listener-tls-secret"}]}}
  creationTimestamp: "2023-07-22T18:02:13Z"
  generation: 2
  name: ingress-01
  namespace: test-infra
  resourceVersion: "278238"
  uid: 17c34774-1d92-413e-85ec-c5a8da45989d
spec:
  ingressClassName: azure-alb-external
  rules:
    - host: contoso.com
      http:
        paths:
          - path: /
            pathType: Prefix
            backend:
              service:
                name: backend-v1
                port:
                  number: 8080
    - host: fabrikam.com
      http:
        paths:
          - path: /
            pathType: Prefix
            backend:
              service:
                name: backend-v2
                port:
                  number: 8080
status:
  loadBalancer:
    ingress:
    - hostname: xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx.fzyy.alb.azure.com
      ports:
      - port: 80
        protocol: TCP

Testare l'accesso all'applicazione

A questo punto, è possibile inviare traffico all'applicazione di esempio tramite il nome di dominio completo assegnato al front-end. Usare il comando seguente per ottenere il nome di dominio completo.

fqdn=$(kubectl get ingress ingress-01 -n test-infra -o jsonpath='{.status.loadBalancer.ingress[0].hostname}'')

Specificare quindi l'indicatore del nome del server usando il comando curl, contoso.com per il nome di dominio completo front-end deve restituire una risposta dal servizio back-end-v1.

fqdnIp=$(dig +short $fqdn)
curl -k --resolve contoso.com:80:$fqdnIp http://contoso.com

Tramite la risposta si osserverà quanto segue:

{
 "path": "/",
 "host": "contoso.com",
 "method": "GET",
 "proto": "HTTP/1.1",
 "headers": {
  "Accept": [
   "*/*"
  ],
  "User-Agent": [
   "curl/7.81.0"
  ],
  "X-Forwarded-For": [
   "xxx.xxx.xxx.xxx"
  ],
  "X-Forwarded-Proto": [
   "http"
  ],
  "X-Request-Id": [
   "dcd4bcad-ea43-4fb6-948e-a906380dcd6d"
  ]
 },
 "namespace": "test-infra",
 "ingress": "",
 "service": "",
 "pod": "backend-v1-5b8fd96959-f59mm"
}

Specificare quindi l'indicatore del nome del server usando il comando curl, fabrikam.com per il nome di dominio completo front-end deve restituire una risposta dal servizio back-end-v1.

fqdnIp=$(dig +short $fqdn)
curl -k --resolve fabrikam.com:80:$fqdnIp http://fabrikam.com

Tramite la risposta si osserverà quanto segue:

{
 "path": "/",
 "host": "fabrikam.com",
 "method": "GET",
 "proto": "HTTP/1.1",
 "headers": {
  "Accept": [
   "*/*"
  ],
  "User-Agent": [
   "curl/7.81.0"
  ],
  "X-Forwarded-For": [
   "xxx.xxx.xxx.xxx"
  ],
  "X-Forwarded-Proto": [
   "http"
  ],
  "X-Request-Id": [
   "adae8cc1-8030-4d95-9e05-237dd4e3941b"
  ]
 },
 "namespace": "test-infra",
 "ingress": "",
 "service": "",
 "pod": "backend-v2-594bd59865-ppv9w"
}

Congratulazioni, il controller ALB è stato installato, è stata distribuita un'applicazione back-end e il traffico è stato instradato a due servizi back-end distinti usando nomi host diversi tramite l'API in ingresso nel Gateway applicativo per contenitori.