Princípios e configuração de DNS - Container Compute Service: Central de Documentação do Alibaba Cloud

Ative a resolução de DNS no seu cluster

A resolução de DNS não vem ativada por padrão em clusters ACS. Para ativá-la, selecione o CoreDNS durante a criação do cluster. O CoreDNS é exposto internamente como um Service chamado kube-dns no namespace kube-system.

Execute o comando abaixo para verificar o Service kube-dns:

kubectl get svc kube-dns -n kube-system

Saída esperada:

NAME       TYPE        CLUSTER-IP    EXTERNAL-IP   PORT(S)                  AGE
kube-dns   ClusterIP   172.24.0.10   <none>        53/UDP,53/TCP,9153/TCP   27d

Para mais detalhes sobre a criação de um cluster ACS com o CoreDNS ativado, consulte Criar um cluster ACS.

Funcionamento da resolução de DNS em clusters ACS

Ao iniciar um Pod, o kubelet define as configurações de DNS com base em dois parâmetros:

--cluster-dns=<dns-service-ip>: endereço IP do servidor DNS do cluster.
--cluster-domain=<default-local-domain>: sufixo do nome de domínio base.

Esses parâmetros definem o conteúdo do arquivo /etc/resolv.conf dentro de cada Pod:

nameserver xx.xx.0.10
search kube-system.svc.cluster.local svc.cluster.local cluster.local
options ndots:5

Parâmetro	Descrição
`nameserver`	Endereço IP do servidor DNS.
`search`	Sufixos de domínio adicionados a nomes curtos durante a consulta DNS. Clusters ACS incluem três sufixos (`kube-system.svc.cluster.local`, `svc.cluster.local` e `cluster.local`), o que pode gerar até quatro consultas DNS em uma única busca.
`options`	Opções adicionais do resolvedor em formato chave-valor. O valor padrão `ndots:5` indica que: se um nome de domínio tiver mais pontos que o valor de `ndots`, ele será tratado como um nome de domínio totalmente qualificado (FQDN) e resolvido diretamente; caso contrário, os sufixos de `search` serão anexados primeiro.

Escolha uma política de DNS

Defina a dnsPolicy na especificação do Pod para controlar a forma como ele resolve nomes de domínio. Os clusters ACS suportam as seguintes políticas:

Política	Servidor DNS utilizado	Cenário recomendado
`ClusterFirst`	CoreDNS (`kube-dns`)	Ideal para Pods que precisam acessar outros Services no cluster. Esta é a configuração padrão.
`None`	Definido por `dnsConfig`	Indicado para Pods que exigem configurações de DNS totalmente personalizadas.
`Default`	`/etc/resolv.conf` do nó (Alibaba Cloud DNS)	Adequado para Pods que não acessam Services internos do cluster.

A política Default não é a padrão. Caso a dnsPolicy não seja especificada, o sistema utilizará a ClusterFirst.

Utilize o CoreDNS para resolver nomes de domínio internos do cluster

Configure dnsPolicy: ClusterFirst para Pods que se comunicam com outros Services no cluster. Este é o comportamento padrão para cargas de trabalho no ACS.

apiVersion: v1
kind: Pod
metadata:
  name: alpine
  namespace: default
spec:
  containers:
  - image: alpine
    command:
      - sleep
      - "10000"
    imagePullPolicy: Always
    name: alpine
  dnsPolicy: ClusterFirst

Personalize as configurações de DNS de um Pod

Defina dnsPolicy: None e forneça um bloco dnsConfig para ter controle total sobre as configurações de DNS do Pod. Quando a dnsPolicy for None, é obrigatório especificar pelo menos um nameserver no dnsConfig.

O campo dnsConfig é opcional e pode ser combinado com qualquer dnsPolicy, não apenas com a None. Use-o com outras políticas para adicionar nameservers ou domínios de busca extras às configurações existentes.

apiVersion: v1
kind: Pod
metadata:
  name: alpine
  namespace: default
spec:
  containers:
  - image: alpine
    command:
      - sleep
      - "10000"
    imagePullPolicy: Always
    name: alpine
  dnsPolicy: None
  dnsConfig:
    nameservers: ["169.254.xx.xx"]
    searches:
    - default.svc.cluster.local
    - svc.cluster.local
    - cluster.local
    options:
    - name: ndots
      value: "2"

Ao iniciar o Pod, a configuração acima gera o seguinte conteúdo em /etc/resolv.conf:

nameserver 169.254.xx.xx
search default.svc.cluster.local svc.cluster.local cluster.local
options ndots:2

A tabela a seguir descreve os campos do dnsConfig:

Campo	Descrição
`nameservers`	Lista de endereços IP dos servidores DNS para o Pod. São permitidos até três endereços IP. Se a `dnsPolicy` for `None`, pelo menos um endereço deve ser especificado. Endereços duplicados são removidos automaticamente.
`searches`	Lista de domínios de busca DNS para consultas de hostname. O limite é de seis domínios. Eles são anexados à lista base derivada da política de DNS. Domínios duplicados são removidos.
`options`	Lista de opções do resolvedor, cada uma contendo um `name` (obrigatório) e um `value` (opcional). Essas opções são mescladas às geradas pela política de DNS. Itens duplicados são removidos.

Utilize DNS no nível do nó sem o CoreDNS

Caso seus Pods não precisem acessar Services no cluster ACS, defina dnsPolicy: Default. A resolução de DNS será gerenciada pelo Alibaba Cloud DNS através do arquivo /etc/resolv.conf do nó, sem envolver o CoreDNS.

apiVersion: v1
kind: Pod
metadata:
  name: alpine
  namespace: default
spec:
  containers:
  - image: alpine
    command:
      - sleep
      - "10000"
    imagePullPolicy: Always
    name: alpine
  dnsPolicy: Default

Mapeie hostnames estáticos para endereços IP

Para adicionar mapeamentos estáticos de hostname para IP em um Pod específico, inclua o campo hostAliases na especificação do Pod. O kubelet gerencia o arquivo /etc/hosts do Pod e grava essas entradas durante a inicialização.

Aviso

Não edite manualmente o arquivo /etc/hosts dentro de um container em execução. O kubelet sobrescreve esse arquivo sempre que o container reinicia, fazendo com que alterações manuais sejam perdidas.

Para aplicar mapeamentos estáticos a todos os Pods do cluster em vez de apenas um, ative o plug-in hosts do CoreDNS. Consulte Configurar extensões do CoreDNS.

O exemplo abaixo mapeia foo.local, bar.local e foo.remote para endereços IP estáticos:

apiVersion: v1
kind: Pod
metadata:
  name: hostaliases-pod
spec:
  hostAliases:
  - ip: "127.0.**.**"
    hostnames:
    - "foo.local"
    - "bar.local"
  - ip: "10.1.**.**"
    hostnames:
    - "foo.remote"
  containers:
  - name: cat-hosts
    image: busybox:1.28
    command:
    - cat
    args:
    - "/etc/hosts"

Após a inicialização do Pod, o arquivo /etc/hosts conterá:

# Kubernetes-managed hosts file.
127.0.**.**	localhost
10.200.**.**	hostaliases-pod

# Entries added by HostAliases.
127.0.**.**	foo.local	bar.local
10.1.**.**	foo.remote	bar.remote

Próximos passos

Configurar extensões do CoreDNS