Use ALB Ingress on a self-managed K8s cluster - Server Load Balancer

Exemple de scénario

Cette rubrique s'appuie sur le scénario illustré dans la figure suivante, où un cluster Kubernetes autonome hébergé sur Alibaba Cloud utilise une entrée ALB pour acheminer les requêtes.

Déployez le contrôleur alb-ingress-controller et créez des ressources Ingress et Service dans votre cluster Kubernetes autonome. Le contrôleur alb-ingress-controller synchronise les configurations d'entrée vers une instance ALB sous forme de règles de transfert. Il surveille également l'API Server du cluster pour détecter les modifications apportées aux entrées et synchronise ces mises à jour avec l'instance ALB. L'instance ALB achemine ensuite dynamiquement le trafic vers les pods correspondants dans le cluster. Pour plus d'informations, consultez la rubrique Gestion des entrées ALB.

ALB Ingress场景示例

Remarques d'utilisation

Si vous utilisez un plug-in de réseau superposé, tel que Flannel, le service backend de l'entrée ALB doit être de type NodePort ou LoadBalancer.
Les noms des ressources AlbConfig, Namespace, Ingress et Service ne peuvent pas commencer par aliyun.

Prérequis

Vous disposez d'un cluster Kubernetes autonome (version 1.20 ou ultérieure) hébergé sur Alibaba Cloud. Vous pouvez vous connecter au cluster à l'aide de kubectl. Pour savoir comment télécharger et installer kubectl, consultez la page Installer et configurer kubectl.
Vous avez configuré la traduction d'adresses source (SNAT) pour permettre l'accès Internet au cluster autonome. Pour plus d'informations, consultez la rubrique Utiliser la fonctionnalité SNAT d'une passerelle NAT Internet pour accéder à Internet.
Lorsque vous utilisez une image de contrôleur pour votre cluster autonome, tenez compte des éléments suivants :
- Si vous utilisez une image privée, compilez-la et téléchargez-la en suivant les instructions fournies dans Déployer le contrôleur à partir du code source.
- Pour les clusters dotés d'une architecture x86 standard, vous pouvez utiliser l'image publique fournie par Alibaba Cloud à des fins de test.

Procédure

配置步骤

Les étapes suivantes impliquent la modification de plusieurs fichiers. Le tableau ci-dessous décrit l'objectif de chacun d'eux.

Étape

Nom du fichier

Objectif

Étape 1 : Déployer le contrôleur alb-ingress-controller

load-balancer-controller.yaml

Modifié à partir d'un modèle

Déployer le contrôleur alb-ingress-controller

Étape 2 : Créer les ressources AlbConfig et IngressClass

alb.yaml

Créé et modifié

Créer les ressources AlbConfig et IngressClass, ce qui entraîne la création automatique d'une instance ALB

Étape 3 : Déployer une application de test

test-service.yaml

Créé et modifié

Déployer un service de test

Étape 4 : Créer une entrée

test-ingress.yaml

Créé et modifié

Créer une entrée

Étape 1 : Déployer le contrôleur alb-ingress-controller

Remarque

Le téléchargement de l'image de déploiement peut échouer en raison de problèmes de réseau liés au fournisseur d'accès Internet. Pour éviter cela, utilisez une image privée. Compilez-la et téléchargez-la en suivant les instructions fournies dans Déployer le contrôleur à partir du code source.

Dans cette rubrique, le contrôleur alb-ingress-controller démarre en mode InCluster. Après avoir configuré les autorisations nécessaires pour surveiller les ressources de type service, endpoint et node, utilisez le fichier load-balancer-controller.yaml pour déployer le contrôleur alb-ingress-controller. Les objets ServiceAccount, Deployment et ConfigMap requis sont préconfigurés. Il vous suffit de les modifier pour les adapter à votre environnement.

Modifiez le fichier load-balancer-controller.yaml afin de remplacer l'image du déploiement par une adresse d'image accessible.
Le fichier load-balancer-controller.yaml sert à déployer le contrôleur alb-ingress-controller.
Avant modification :
```
image: ${path/to/your/image/registry}
```
Après modification :
```
image: alibabacloudslb/alibaba-load-balancer-controller:v1.2.0  # An x86-compiled image.
```

Modifiez le fichier load-balancer-controller.yaml pour configurer l'AccessKey ID et l'AccessKey Secret dans la ConfigMap.

Remarque

Connectez-vous à la console RAM avec le compte Alibaba Cloud que vous souhaitez utiliser pour créer l'instance ALB. Consultez ensuite l'AccessKey ID et l'AccessKey Secret sur la page AccessKey.

apiVersion: v1
kind: ConfigMap
metadata:
  name: load-balancer-config
  namespace: kube-system
data:
  cloud-config.conf: |-
       {
           "Global": {
               "AccessKeyID": "<YOUR_ACCESS_KEY_ID>", # Base64 encoding is required.
               "AccessKeySecret": "<YOUR_ACCESS_KEY_SECRET>" # Base64 encoding is required.
           }
       }

Connectez-vous au cluster à l'aide de kubectl et exécutez la commande suivante pour appliquer le fichier load-balancer-controller.yaml modifié.

kubectl apply -f load-balancer-controller.yaml

Résultat attendu :

clusterrole.rbac.authorization.k8s.io/system:load-balancer-controller created
serviceaccount/load-balancer-controller created
clusterrolebinding.rbac.authorization.k8s.io/system:load-controller-manager created
configmap/load-balancer-config created
deployment.apps/load-balancer-controller created

Exécutez la commande suivante pour vérifier le déploiement du contrôleur alb-ingress-controller.

kubectl -n kube-system get all | grep load-balancer

La sortie suivante indique que le pod est dans l'état Running, ce qui confirme que le déploiement a réussi.

[root@iZ2ze9xxx uoZ test]# kubectl -n kube-system get all | grep load-balancer
pod/load-balancer-controller-67985dd48d-qtgl8       1/1     Running   0          61d
deployment.apps/load-balancer-controller   1/1   1            1           62d
replicaset.apps/load-balancer-controller-67985dd48d   1         1         1       62d

Étape 2 : Créer les ressources AlbConfig et IngressClass

Après la création des ressources AlbConfig et IngressClass, une instance ALB est automatiquement créée.

Créez un fichier nommé alb.yaml et copiez-y le contenu suivant.
Le fichier alb.yaml sert à créer les ressources AlbConfig et IngressClass.
```
apiVersion: alibabacloud.com/v1
kind: AlbConfig
metadata:
  name: alb-demo
spec:
  config:
    name: alb-test             # The name of the ALB instance.
    addressType: Internet      # Use 'Internet' for public-facing or 'Intranet' for private.
    zoneMappings:
    - vSwitchId: vsw-wz9e2usil7e5an1xi****    # Specify vSwitch IDs in at least two zones.
    - vSwitchId: vsw-wz92lvykqj1siwvif****
  listeners:
    - port: 80
      protocol: HTTP
---
apiVersion: networking.k8s.io/v1
kind: IngressClass
metadata:
  name: alb
spec:
  controller: ingress.k8s.alibabacloud/alb
  parameters:
    apiGroup: alibabacloud.com
    kind: AlbConfig
    name: alb-demo   # The referenced AlbConfig resource.
```
Remarque
Prenez note des paramètres suivants :
- albconfig.spec.config.addressType : le type de réseau de l'instance. Valeurs possibles :
  
  Internet (par défaut) : crée une instance exposée publiquement. Une adresse IP publique et une adresse IP privée sont attribuées à chaque zone. Les instances ALB publiques utilisent une adresse IP élastique (EIP) pour fournir des services via Internet. Des frais d'instance et des frais de transfert de données pour l'EIP vous sont facturés.
  
  L'EIP permet un accès Internet public à l'instance ALB.
  
  L'adresse IP privée permet d'accéder à l'instance ALB depuis les instances ECS situées dans le même VPC.
  
  Intranet : crée une instance privée. Une adresse IP privée est attribuée à chaque zone. L'instance ALB n'est accessible qu'à partir du réseau Alibaba Cloud et ne peut pas être atteinte depuis Internet.
- spec.config.zoneMappings : spécifie les ID de vSwitch pour l'entrée ALB. Vous devez indiquer au moins deux ID de vSwitch provenant de zones différentes. Les vSwitch spécifiés doivent se trouver dans des zones prises en charge par l'instance ALB actuelle. Pour plus d'informations sur les régions et les zones prises en charge par ALB, consultez la rubrique Régions et zones prises en charge.
Connectez-vous au cluster à l'aide de kubectl et exécutez la commande suivante pour appliquer le fichier alb.yaml.
```
kubectl apply -f alb.yaml
```
Résultat attendu :
```
AlbConfig.alibabacloud.com/alb-demo created
ingressclass.networking.k8s.io/alb created
```
Vérifiez la création de l'instance ALB.
- Méthode 1 : exécutez la commande suivante pour afficher l'ID de l'instance ALB.
```
kubectl get albconfig alb-demo     
```
```
[root@i-xxx nuoZ test]# kubectl get albconfig alb-demo
NAME        ALBID                      DNSNAME                                          PORT&PROTOCOL   CERTID   AGE
alb-demo    alb-3lzokczr3c9guq7zz7    alb-3xxx.com                                                               84s
```
- Méthode 2 : connectez-vous à la console ALB pour afficher l'instance ALB créée.
  
  Remarque
  Vous devez vous connecter à la console avec le compte Alibaba Cloud que vous avez configuré dans la ConfigMap à l'étape Étape 1 : Déployer le contrôleur alb-ingress-controller.

Étape 3 : Déployer une application de test

Cette section vous guide dans l'utilisation d'une image de test pour créer des ressources de déploiement et déployer une application de test.

Créez un fichier nommé test-service.yaml et copiez-y le contenu suivant.

Le fichier test-service.yaml sert à déployer deux déploiements nommés test01 et test02, ainsi que deux services nommés test01-service et test02-service.

apiVersion: apps/v1
kind: Deployment
metadata:
  name: test01
spec:
  replicas: 2
  selector:
    matchLabels:
      app: test01
  template:
    metadata:
      labels:
        app: test01
    spec:
      containers:
      - name: test01
        image: registry.cn-hangzhou.aliyuncs.com/acs-sample/nginxdemos:latest
        ports:
        - containerPort: 80
---
apiVersion: v1
kind: Service
metadata:
  name: test01-service
spec:
  ports:
  - port: 80
    targetPort: 80
    protocol: TCP
  selector:
    app: test01
  type: NodePort
---
apiVersion: apps/v1
kind: Deployment
metadata:
  name: test02
spec:
  replicas: 1
  selector:
    matchLabels:
      app: test02
  template:
    metadata:
      labels:
        app: test02
    spec:
      containers:
      - name: test02
        image: registry.cn-hangzhou.aliyuncs.com/acs-sample/nginxdemos:latest
        ports:
        - containerPort: 80
---
apiVersion: v1
kind: Service
metadata:
  name: test02-service
spec:
  ports:
  - port: 80
    targetPort: 80
    protocol: TCP
  selector:
    app: test02
  type: NodePort

Connectez-vous au cluster à l'aide de kubectl et exécutez la commande suivante pour appliquer le fichier test-service.yaml.

kubectl apply -f test-service.yaml

Résultat attendu :

deployment.apps/test01 created
service/test01-service created
deployment.apps/test02 created
service/test02-service created

Exécutez la commande suivante pour vérifier que les services de test ont été déployés avec succès.

kubectl get svc,deploy

La sortie suivante indique que les services de test sont déployés avec succès.

[root@iZ2z***uoZ test]# kubectl get svc,deploy
NAME                        TYPE        CLUSTER-IP      EXTERNAL-IP   PORT(S)          AGE
service/cloud-nodeport      NodePort    10.xxx.122      <none>        80:31310/TCP     63d
service/kubernetes          ClusterIP   10.xxx.1        <none>        443/TCP          63d
service/test01-service      NodePort    10.xxx.121      <none>        80:31254/TCP     9s
service/test02-service      NodePort    10.xxx.118      <none>        80:30337/TCP     9s
NAME                                        READY   UP-TO-DATE   AVAILABLE   AGE
deployment.apps/openresty-deployment        2/2     2            2           63d
deployment.apps/test01                      2/2     2            2           9s
deployment.apps/test02                      1/1     1            1           9s

Étape 4 : Créer une entrée

Une entrée correspond à une règle de transfert dans une instance ALB. Cette rubrique utilise le routage basé sur le chemin d'accès. Pour plus d'informations sur les fonctionnalités avancées, consultez le Guide d'utilisation de l'entrée ALB.

Créez un fichier nommé test-ingress.yaml et copiez-y le contenu suivant.

Le fichier test-ingress.yaml sert à créer une entrée.

apiVersion: networking.k8s.io/v1
kind: Ingress
metadata:
  name: test-ingress
spec:
  ingressClassName: alb
  rules:
   - host: demo.domain.ingress.top
     http:
      paths:
      - path: /test01
        pathType: Prefix
        backend:
          service:
            name: test01-service
            port:
              number: 80
      - path: /test02
        pathType: Prefix
        backend:
          service:
            name: test02-service
            port:
              number: 80

Connectez-vous au cluster à l'aide de kubectl et exécutez la commande suivante pour appliquer le fichier test-ingress.yaml.
```
kubectl apply -f test-ingress.yaml
```
Résultat attendu :
```
ingress.networking.k8s.io/test-ingress created
```

Exécutez la commande suivante pour vérifier la création de la ressource test-ingress.

kubectl get ingress

La sortie suivante indique que la ressource test-ingress a été créée avec succès.

[root@iZ2zxxx test]# kubectl get ingress
NAME           CLASS   HOSTS                    ADDRESS                                                        PORTS   AGE
test-ingress   alb     demo.domain.ingress.top  alb-xxx.cn-beijing.alb.aliyuncs.com   80      19s

Étape 5 : Vérifier les résultats

Accès par nom de domaine

Créez un enregistrement CNAME pour mapper votre nom de domaine au nom DNS de l'instance ALB. Pour plus d'informations, consultez la rubrique Configurer un enregistrement CNAME pour une instance ALB.

Dans cet exemple, supposons que vous mappez le nom de domaine personnalisé demo.domain.ingress.top au nom DNS public de l'instance ALB.
Exécutez la commande suivante pour accéder au service test01 via l'instance ALB.
```
curl http://demo.domain.ingress.top/test01
```
Le pod backend NGINX renvoie une réponse contenant des détails tels que l'adresse du serveur (10.xxx.xxx.xxx:80), le nom du serveur (test01-648bf46944-kvlhj), la date (07/Nov/2022:08:16:35 +0000) et l'URI (/test01). Cela confirme que l'entrée a correctement acheminé la requête vers un pod backend pour le service test01.
Exécutez la commande suivante pour accéder au service test02 via l'instance ALB.
```
curl http://demo.domain.ingress.top/test02
```
La commande renvoie la page de test NGINX, qui indique que l'adresse du serveur est 10.xxx.20:80, que le nom du serveur est test02-76d96f7b8d-6mtnn et que l'URI est /test02. Cela confirme que l'entrée a correctement acheminé la requête vers le pod backend test02.

Pour toute question, rejoignez le groupe de clients ALB (ID DingTalk : 31945843) pour obtenir de l'aide.

Documentation connexe

Présentation et fonctionnalités de l'entrée ALB :

Documentation relative au code source :