Come si configura ExternalDNS con Amazon EKS?

5 minuti di lettura
0

Desidero configurare ExternalDNS con il mio Amazon Elastic Kubernetes Service (Amazon EKS).

Breve descrizione

Per installare ExternalDNS, utilizza le autorizzazioni AWS Identity and Access Management (IAM) per concedere ad Amazon EKS l'accesso necessario per interagire con Amazon Route 53.

Nota: Prima di iniziare la seguente risoluzione, assicurati di avere un nome di dominio e una zona ospitata su Route 53.

Risoluzione

Configura le autorizzazioni IAM e implementa ExternalDNS

Completa i seguenti passaggi:

  1. Crea la policy seguente per configurare le autorizzazioni IAM che concedono al pod ExternalDNS le autorizzazioni per creare, aggiornare ed eliminare i record Route 53 nel tuo account AWS:

    {
      "Version": "2012-10-17",
      "Statement": [
        {
          "Effect": "Allow",
          "Action": [
            "route53:ChangeResourceRecordSets"
          ],
          "Resource": [
            "arn:aws:route53:::hostedzone/"
          ]
        },
        {
          "Effect": "Allow",
          "Action": [
            "route53:ListHostedZones",
            "route53:ListResourceRecordSets",
            "route53:ListTagsForResource"
          ],
          "Resource": [
            "*"
          ]
        }
      ]
    }

    Nota: Puoi modificare la policy precedente per consentire gli aggiornamenti degli ID specifici delle zone ospitate.

  2. Utilizza la policy per creare un ruolo IAM per l'account del servizio:

    eksctl create iamserviceaccount --name SERVICE_ACCOUNT_NAME --namespace NAMESPACE
    --cluster CLUSTER_NAME --attach-policy-arn IAM_POLICY_ARN --approve

    **Nota:**Sostituisci SERVICE_ACCOUNT_NAME con il nome del tuo account del servizio, NAMESPACE con il tuo namespace, CLUSTER_NAME con il nome del tuo cluster e IAM_POLICY_ARN con l'ARN della tua policy IAM.
    Per verificare il nome del tuo account del servizio, esegui il seguente comando:

    kubectl get sa

    Nell'output di esempio seguente, external-dns è il nome assegnato all'account del servizio al momento della creazione:

    NAME           SECRETS   AGE
    default        1         23h
    external-dns   1         23h
  3. Esegui il comando seguente per determinare se RBAC è attivato nel tuo cluster Amazon EKS:  

    kubectl api-versions | grep rbac.authorization.k8s.io

    Nota: Per il comando precedente, verifica la versione più recente di ExternalDNS disponibile nel progetto GitHub.

  4. Esegui il comando seguente per distribuire ExternalDNS:

    kubectl apply DEPLOYMENT_MANIFEST_FILE_NAME.yaml

    **Nota:**Sostituisci DEPLOYMENT_MANIFEST_FILE_NAME con il nome file del manifesto di implementazione.

    Se RBAC è attivato, utilizza il seguente manifesto per implementare ExternalDNS:

    apiVersion: rbac.authorization.k8s.io/v1
    kind: ClusterRole
    metadata:
      name: external-dns
      labels:
        app.kubernetes.io/name: external-dns
    rules:
      - apiGroups: [""]
        resources: ["services","endpoints","pods","nodes"]
        verbs: ["get","watch","list"]
      - apiGroups: ["extensions","networking.k8s.io"]
        resources: ["ingresses"]
        verbs: ["get","watch","list"]
    ---
    apiVersion: rbac.authorization.k8s.io/v1
    kind: ClusterRoleBinding
    metadata:
      name: external-dns-viewer
      labels:
        app.kubernetes.io/name: external-dns
    roleRef:
      apiGroup: rbac.authorization.k8s.io
      kind: ClusterRole
      name: external-dns
    subjects:
      - kind: ServiceAccount
        name: external-dns
        namespace: default # change to desired namespace: externaldns, kube-addons
    ---
    apiVersion: apps/v1
    kind: Deployment
    metadata:
      name: external-dns
      labels:
        app.kubernetes.io/name: external-dns
    spec:
      strategy:
        type: Recreate
      selector:
        matchLabels:
          app.kubernetes.io/name: external-dns
      template:
        metadata:
          labels:
            app.kubernetes.io/name: external-dns
        spec:
          serviceAccountName: external-dns
          containers:
            - name: external-dns
              image: registry.k8s.io/external-dns/external-dns:v0.14.0
              args:
                - --source=service
                - --source=ingress
                - --domain-filter=example.com # will make ExternalDNS see only the hosted zones matching provided domain, omit to process all available hosted zones
                - --provider=aws
                - --policy=upsert-only # would prevent ExternalDNS from deleting any records, omit to enable full synchronization
                - --aws-zone-type=public # only look at public hosted zones (valid values are public, private or no value for both)
                - --registry=txt
                - --txt-owner-id=external-dns
              env:
                - name: AWS_DEFAULT_REGION
                  value: eu-west-1 # change to region where EKS is installed

    Se RBAC non è attivato, utilizza il seguente manifesto per implementare ExternalDNS:

    apiVersion: apps/v1
    kind: Deployment
    metadata:
      name: external-dns
      labels:
        app.kubernetes.io/name: external-dns
    spec:
      strategy:
        type: Recreate
      selector:
        matchLabels:
          app.kubernetes.io/name: external-dns
      template:
        metadata:
          labels:
            app.kubernetes.io/name: external-dns
        spec:
          containers:
            - name: external-dns
              image: registry.k8s.io/external-dns/external-dns:v0.14.0
              args:
                - --source=service
                - --source=ingress
                - --domain-filter=example.com # will make ExternalDNS see only the hosted zones matching provided domain, omit to process all available hosted zones
                - --provider=aws
                - --policy=upsert-only # would prevent ExternalDNS from deleting any records, omit to enable full synchronization
                - --aws-zone-type=public # only look at public hosted zones (valid values are public, private or no value for both)
                - --registry=txt
                - --txt-owner-id=my-hostedzone-identifier
              env:
                - name: AWS_DEFAULT_REGION
                  value: eu-west-1 # change to region where EKS is installed
  5. Per verificare che l'implementazione sia avvenuta correttamente, esegui il comando seguente:

    kubectl get deployments

    Esempio di output:

    NAME           READY   UP-TO-DATE   AVAILABLE   AGE
    external-dns   1/1     1            1           85m

    Oppure, controlla i log per verificare che i record siano aggiornati:

    kubectl logs external-dns-9f85d8d5b-sx5f

    Esempio di output:

    ....
    time="2023-12-14T17:16:16Z" level=info msg="Instantiating new Kubernetes client"
    time="2023-12-14T17:16:16Z" level=info msg="Using inCluster-config based on serviceaccount-token"
    time="2023-12-14T17:16:16Z" level=info msg="Created Kubernetes client https://10.100.0.1:443"
    time="2023-12-14T17:16:18Z" level=info msg="Applying provider record filter for domains: [xxxxx.people.aws.dev. .xxxxx.people.aws.dev. xxxxx.people.aws.dev. .xxxxx.people.aws.dev.]"
    time="2023-12-14T17:16:18Z" level=info msg="All records are already up to date"
    ....

Verifica DNS esterno

Per confermare che ExternalDNS è impostato correttamente, completa i seguenti passaggi:

  1. Crea un servizio esposto come LoadBalancer. Il servizio deve essere indirizzato esternamente tramite il nome di dominio ospitato su Route 53:

    kubectl apply SERVICE_MANIFEST_FILE_NAME.yaml
    
    Note: Replace SERVICE_MANIFEST_FILE_NAME with your service manifest's file name.
    
    Manifest:
    
    apiVersion: v1
    kind: Service
    metadata:
      name: nginx
      annotations:
        external-dns.alpha.kubernetes.io/hostname: nginx.xxxxx.people.aws.dev
    spec:
      ports:
        - port: 80
          targetPort: 80
          protocol: TCP
      type: LoadBalancer
      selector:
        app: nginx
    
    ---
    apiVersion: apps/v1
    kind: Deployment
    metadata:
      name: nginx
    spec:
      selector:
        matchLabels:
          app: nginx
      template:
        metadata:
          labels:
            app: nginx
        spec:
          containers:
            - image: nginx
              name: nginx
              ports:
                - containerPort: 80
                  name: http

    Nota: ExternalDNS utilizza l'annotazione external-dns.alpha.kubernetes.io/hostname sui servizi. Utilizza anche i valori associati. Per assegnare più nomi a un servizio, configura l'annotazione external-dns.alpha.kubernetes.io/hostname con un separatore di virgole.

  2. Verifica che il servizio NGINX sia stato creato con il tipo LoadBalancer:

    kubectl get svc

    Esempio di output:

    NAME         TYPE           CLUSTER-IP      EXTERNAL-IP                                                              PORT(S)        AGE
    kubernetes   ClusterIP      10.100.0.1      <none>                                                                   443/TCP        05h
    nginx        LoadBalancer   10.100.254.68   xxxxyyyyzzzz-123456789.eu-west-1.elb.amazonaws.com   80:30792/TCP   74m
    

    **Nota:**Il servizio crea automaticamente un record Route 53 per la zona ospitata.

  3. Esegui il comando seguente per visualizzare i log e confermare che il record Route 53 sia stato creato correttamente:

    kubectl logs external-dns-9f85d8d5b-sx5fg

    Esempio di output:

    ...
    time="2023-12-14T17:19:19Z" level=info msg="Desired change: CREATE cname-nginx.xxxxx.people.aws.dev TXT [Id: /hostedzone/Z0786329GDVAZMXYZ]"
    time="2023-12-14T17:19:19Z" level=info msg="Desired change: CREATE nginx.xxxxx.people.aws.dev A [Id: /hostedzone/Z0786329GDVAZMXYZ]"
    time="2023-12-14T17:19:19Z" level=info msg="Desired change: CREATE nginx.xxxxx.people.aws.dev TXT [Id: /hostedzone/Z0786329GDVAZMXYZ]"
    time="2023-12-14T17:19:20Z" level=info msg="3 record(s) in zone xxxxx.people.aws.dev. [Id: /hostedzone/Z0786329GDVAZMXYZ] were successfully updated"
    ...
AWS UFFICIALE
AWS UFFICIALEAggiornata 8 mesi fa