Como faço para configurar o ExternalDNS com o Amazon EKS?

6 minuto de leitura
0

Quero configurar o ExternalDNS com meu Amazon Elastic Kubernetes Service (Amazon EKS).

Breve descrição

Para instalar o ExternalDNS, use as permissões do AWS Identity and Access Management (IAM) para conceder ao Amazon EKS o acesso necessário para interagir com o Amazon Route 53.

Observação: antes de iniciar a resolução a seguir, certifique-se de que existam um nome de domínio e uma zona hospedada no Route 53.

Resolução

Configurar as permissões do IAM e implante o ExternalDNS

Conclua as seguintes etapas:

  1. Crie a política a seguir para configurar as permissões do IAM para conceder ao pod ExternalDNS permissões para criar, atualizar e excluir registros do Route 53 em sua conta da 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": [
            "*"
          ]
        }
      ]
    }

    Observação: você pode modificar a política anterior para permitir atualizações em IDs de zona hospedada específica.

  2. Use a política anterior para criar um perfil do IAM para a conta de serviço:

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

    Observação: substitua SERVICE_ACCOUNT_NAME pelo nome da sua conta de serviço, NAMESPACE pelo seu namespace, CLUSTER_NAME pelo nome do cluster e IAM_POLICY_ARN pelo ARN da sua política do IAM.
    Para verificar o nome da sua conta de serviço, execute o seguinte comando:

    kubectl get sa

    Na saída do exemplo a seguir, external-dns é o nome dado à conta de serviço quando ela foi criada:

    NAME           SECRETS   AGE
    default        1         23h
    external-dns   1         23h
  3. Execute o comando a seguir para determinar se o RBAC está ativado em seu cluster Amazon EKS:

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

    Observação: para o comando anterior, verifique a versão mais recente do ExternalDNS que está disponível no projeto GitHub.

  4. Execute o seguinte comando para implantar o ExternalDNS:

    kubectl apply DEPLOYMENT_MANIFEST_FILE_NAME.yaml

    Observação: substitua DEPLOYMENT_MANIFEST_FILE_NAME pelo nome do arquivo do manifesto de implantação.

    Se o RBAC estiver ativado, use o seguinte manifesto para implantar o 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 o RBAC não estiver ativado, use o seguinte manifesto para implantar o 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. Execute o comando a seguir para verificar se a implantação foi bem-sucedida:

    kubectl get deployments

    Exemplo de saída:

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

    Ou verifique os logs para verificar se os registros estão atualizados:

    kubectl logs external-dns-9f85d8d5b-sx5f

    Exemplo de saída:

    ....
    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"
    ....

Verificar o ExternalDNS

Para confirmar se o ExternalDNS está configurado corretamente, conclua as seguintes etapas:

  1. Crie um serviço que seja exposto como LoadBalancer. O serviço deve ser roteado externamente por meio do nome de domínio hospedado no 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

    Observação: o ExternalDNS usa a anotação external-dns.alpha.kubernetes.io/hostname nos serviços. Ele também usa os valores associados. Para atribuir vários nomes a um serviço, configure a anotação external-dns.alpha.kubernetes.io/hostname com um separador de vírgula.

  2. Verifique se o serviço NGINX é criado com o tipo LoadBalancer:

    kubectl get svc

    Exemplo de saída:

    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
    

    Observação: o serviço cria automaticamente um registro do Route 53 para a zona hospedada.

  3. Execute o comando a seguir para visualizar os logs e confirme se o registro do Route 53 foi criado com êxito:

    kubectl logs external-dns-9f85d8d5b-sx5fg

    Exemplo de saída:

    ...
    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 OFICIAL
AWS OFICIALAtualizada há 8 meses