One place for hosting & domains

      Como adicionar o teste de unidade ao seu projeto Django


      O autor selecionou a Open Internet/Free Speech Fund para receber uma doação como parte do programa Write for DOnations.

      Introdução

      É quase impossível desenvolver sites que funcionem perfeitamente na primeira vez, sem erro algum. Por este motivo, você deve testar seu aplicativo Web em busca de erros e trabalhar neles proativamente. Para melhorar a eficiência dos testes, é comum dividir os testes em unidades que testam funcionalidades específicas de um aplicativo Web. Esta prática é conhecida como teste de unidade. Esta prática facilita a detecção de erros, pois os testes focam em partes menores (unidades) do seu projeto, independentemente das outras.

      O teste de um site pode ser uma tarefa complexa de se realizar, pois um site é composto de várias camadas lógicas, como o processamento de solicitações HTTP, validação do formulário e renderização de modelos. No entanto, o Django fornece um conjunto de ferramentas que simplifica o teste de seu aplicativo Web. No Django, o melhor método de escrever os testes é através do uso do módulo unittest do Python, embora seja possível utilizar outros frameworks de teste.

      Neste tutorial, você configurará um conjunto de testes em seu projeto Django e escreverá os testes de unidade para os modelos e visualizações em seu aplicativo. Você executará esses testes, analisará os resultados e aprenderá como encontrar as causas das falhas dos testes.

      Pré-requisitos

      Antes de começar este tutorial será necessário:

      Passo 1 — Adicionando um conjunto de testes para seu aplicativo Django

      Um conjunto de teste é uma coleção de todos os casos de teste em todos os aplicativos em seu projeto. Para que seja possível que o utilitário de testes do Django descubra os casos de teste que você possui, escreva os casos de teste em scripts cujos nomes comecem com test. Neste passo você criará a estrutura do diretório e os arquivos para seu conjunto de testes e criará um caso de teste vazio nele.

      Se você seguiu o a série de tutoriais de desenvolvimento do Django, você terá consigo um aplicativo Django chamado blogsite.

      Vamos criar uma pasta para armazenar todos os nossos scripts de testes. Primeiro, ative o ambiente virtual:

      • cd ~/my_blog_app
      • . env/bin/activate

      Em seguida, vá até o diretório do aplicativo chamado blogsite. Esta é a pasta que contém os arquivos models.py e views.py. Crie nela uma nova pasta chamada tests:

      • cd ~/my_blog_app/blog/blogsite
      • mkdir tests

      Depois disso, você transformará esta pasta em um pacote Python. Por este motivo, adicione um arquivo __init__.py:

      • cd ~/my_blog_app/blog/blogsite/tests
      • touch __init__.py

      Agora, você adicionará um arquivo para testar seus modelos e outro arquivo para testar suas visualizações:

      • touch test_models.py
      • touch test_views.py

      Por fim, você criará um caso de teste vazio em test_models.py. Você precisará importar a classe Django TestCase e torná-la uma superclasse de sua própria classe de caso de teste. Mais à frente, você adicionará métodos para este caso de teste para testar a lógica em seus modelos. Abra o arquivo test_models.py​​​:

      Agora, adicione o código a seguir ao arquivo:

      ~/my_blog_app/blog/blogsite/tests/test_models.py

      from django.test import TestCase
      
      class ModelsTestCase(TestCase):
          pass
      

      Você adicionou um conjunto de testes ao aplicativo blogsite. Em seguida, você preencherá os detalhes do modelo do caso de teste vazio criado aqui.

      Passo 2 — Testando o código Python

      Neste passo você testará a lógica do código escrito no arquivo models.py. Você estará testando especificamente o método save do modelo Post para garantir que ele crie o campo de dados dinâmico correto do título de uma postagem quando ela for chamada.

      Vamos começar analisando o código que você já tem em seu arquivo models.py para o método save do modelo Post:

      • cd ~/my_blog_app/blog/blogsite
      • nano models.py

      Você verá o seguinte:

      ~/my_blog_app/blog/blogsite/models.py

      class Post(models.Model):
          ...
          def save(self, *args, **kwargs):
              if not self.slug:
                  self.slug = slugify(self.title)
              super(Post, self).save(*args, **kwargs)
          ...
      

      Como podemos ver, ele verifica se a postagem que está prestes a ser salva possui algum valor do campo de dados dinâmico. Se não tiver, ele chama o slugify para criar um valor do campo de dados dinâmico. Esta é lógica que queremos para testar e garantir que os campos de dados dinâmicos sejam criados ao salvar uma postagem.

      Feche o arquivo.

      Para testar isso, volte para o test_models.py:

      Em seguida, atualize-o para o seguinte, adicionando as partes destacadas:

      ~/my_blog_app/blog/blogsite/tests/test_models.py

      from django.test import TestCase
      from django.template.defaultfilters import slugify
      from blogsite.models import Post
      
      
      class ModelsTestCase(TestCase):
          def test_post_has_slug(self):
              """Posts are given slugs correctly when saving"""
              post = Post.objects.create(title="My first post")
      
              post.author = "John Doe"
              post.save()
              self.assertEqual(post.slug, slugify(post.title))
      

      Este novo método test_post_has_slug cria uma nova postagem com o título "My first post" e, em seguida, fornece um autor à postagem e a salva. Após isso, use o método assertEqual do módulo unittest do Python para verificar se o campo de dados dinâmico para a postagem está correto. O método assertEqual verifica se os dois argumentos passados a ele são iguais aos argumentos determinados pelo operador "==". Caso não sejam iguais, o método gera um erro.

      Salve e saia do test_models.py​​​.

      Este é um exemplo do que pode ser testado. Quanto mais lógica você adicionar ao seu projeto, mais conteúdo haverá para testar. É aconselhável que você crie mais testes caso adicione mais lógica ao método save ou crie novos métodos para o modelo Post. Você pode adicioná-los ao método test_post_has_slug ou criar novos métodos de teste, mas os nomes devem começar com test.

      Você criou um caso de teste para o modelo Post com êxito, onde você definiu que os campos de dados dinâmicos foram criados corretamente após salvar. No próximo passo você escreverá um caso de teste para testar as visualizações.

      Passo 3 — Utilizando o cliente de teste do Django

      Neste passo, você escreverá um caso de teste que testa uma visualização utilizando o cliente de testes do Django. O test client é uma classe Python que age como um navegador Web fictício. Ele permite que você teste suas visualizações e interaja com seu aplicativo Django da mesma forma que um usuário faria. Você pode acessar o cliente de teste referindo-se ao self.client em seus métodos de teste. Por exemplo, vamos criar um caso de teste em test_views.py. Primeiro, abra o arquivo test_views.py​​​:

      Depois, adicione o seguinte:

      ~/my_blog_app/blog/blogsite/tests/test_views.py

      from django.test import TestCase
      
      
      class ViewsTestCase(TestCase):
          def test_index_loads_properly(self):
              """The index page loads properly"""
              response = self.client.get('your_server_ip:8000')
              self.assertEqual(response.status_code, 200)
      

      O ViewsTestCase contém um método test_index_loads_properly que utiliza o cliente de teste do Django para visitar a página inicial do site (http://your_server_ip:8000, onde o your_server_ip é o endereço IP do servidor que você está utilizando). Em seguida, o método de teste verifica se a resposta tem um código de status 200, o que significa que a página respondeu sem erros. Pelo resultado do teste, podemos concluir que quando os usuários visitarem a página, ela responderá sem erros também.

      Além do código de status, você pode ler sobre outras propriedades da resposta do cliente de teste que você confere na página de respostas de testes da documentação do Django.

      Neste passo, você criou um caso de teste para conferir se a renderização da visualização da página inicial funciona sem erros. Agora, existem dois casos de teste em seu conjunto. No próximo passo, você os executará para ver os resultados.

      Passo 4 — Executando seus testes

      Agora que você terminou de desenvolver um conjunto de testes para o projeto, é hora de executá-los e ver os resultados. Para executar os testes, vá para a pasta blog (que contém o arquivo manage.py do aplicativo):

      Em seguida, execute-os com:

      Você verá um resultado parecido com o seguinte em seu terminal:

      Output

      Creating test database for alias 'default'... System check identified no issues (0 silenced). .. ---------------------------------------------------------------------- Ran 2 tests in 0.007s OK Destroying test database for alias 'default'...

      Neste resultado, existem dois pontos .., cada um dos quais representa um caso de teste aprovado. Agora, você modificará o test_views.py para acionar uma falha no teste. Primeiro, abra o arquivo com:

      Em seguida, altere o código destacado para:

      ~/my_blog_app/blog/blogsite/tests/test_views.py

      from django.test import TestCase
      
      
      class ViewsTestCase(TestCase):
          def test_index_loads_properly(self):
              """The index page loads properly"""
              response = self.client.get('your_server_ip:8000')
              self.assertEqual(response.status_code, 404)
      

      Aqui, você alterou o código de status de 200 para 404. Agora, execute o teste novamente do diretório com o manage.py:

      Você verá o seguinte resultado:

      Output

      Creating test database for alias 'default'... System check identified no issues (0 silenced). .F ====================================================================== FAIL: test_index_loads_properly (blogsite.tests.test_views.ViewsTestCase) The index page loads properly ---------------------------------------------------------------------- Traceback (most recent call last): File "~/my_blog_app/blog/blogsite/tests/test_views.py", line 8, in test_index_loads_properly self.assertEqual(response.status_code, 404) AssertionError: 200 != 404 ---------------------------------------------------------------------- Ran 2 tests in 0.007s FAILED (failures=1) Destroying test database for alias 'default'...

      Veja que existe uma mensagem de erro informando o script, o caso de teste e o método que falhou. Ele também diz a causa da falha, o código de status diferente de 404 neste caso, com a mensagem AssertionError: 200 ! = 404. O AssertionError é criado na linha de código destacada no arquivo test_views.py:

      ~/my_blog_app/blog/blogsite/tests/test_views.py

      from django.test import TestCase
      
      
      class ViewsTestCase(TestCase):
          def test_index_loads_properly(self):
              """The index page loads properly"""
              response = self.client.get('your_server_ip:8000')
              self.assertEqual(response.status_code, 404)
      

      Ele informa a você que a afirmação é falsa, ou seja, o código de status da resposta (200) não era o esperado (404). Antes da mensagem de falha, vemos que os dois pontos .. foram modificados para . F, que diz que o primeiro caso de teste foi aprovado enquanto o segundo falhou.

      Conclusão

      Neste tutorial, você criou um conjunto de testes em seu projeto Django, adicionou casos de teste para testar o modelo e a lógica de visualização. Também aprendeu como executar testes e analisou o resultado deles. Como um próximo passo, você pode criar novos scripts de teste para código Python que não sejam do models.py e do views.py.

      Em seguida, temos alguns artigos que podem ser úteis ao desenvolver e testar sites com o Django:

      Você também pode verificar nossa página de tópicos relacionados ao Django para obter mais tutoriais e projetos.



      Source link

      Como implantar e gerenciar seu DNS usando o DNSControl no Debian 10


      O autor selecionou a Electronic Frontier Foundation, Inc para receber uma doação como parte do programa Write for DOnations.

      Introdução

      O DNSControl é uma ferramenta de infraestrutura como código que permite a implantação e gerenciamento de suas zonas DNS (Sistema de Nomes de Domínios, do inglês Domain Name System) usando princípios de desenvolvimento de software padrão, incluindo o controle, teste e implantação automática de versão. O DNSControl foi criado pelo Stack Exchange e foi escrito em Go.

      O DNSControl elimina muitas das armadilhas do gerenciamento manual de DNS, considerando que os arquivos da zona ficam armazenados em um formato programável. Isso permite que você implante zonas para vários provedores de DNS simultaneamente, identifique erros de sintaxe e envie a configuração DNS automaticamente, reduzindo o risco de erro humano. Outro uso comum do DNSControl é a migração rápida de seu DNS para um provedor diferente; por exemplo, no caso de um ataque DDoS ou uma interrupção do sistema.

      Neste tutorial, você instalará e configurará o DNSControl, criará uma configuração básica do DNS e começará a implantar registros DNS em um provedor ativo. Como parte deste tutorial, usaremos a DigitalOcean como o provedor DNS do exemplo. Se quiser usar um provedor diferente, a configuração é bastante parecida. Quando terminar, você conseguirá gerenciar e testar sua configuração de DNS em um ambiente seguro e offline e, depois, poderá implantá-lo para a produção.

      Pré-requisitos

      Antes de iniciar este guia, você precisará do seguinte:

      • Um servidor Debian 10 configurado de acordo com as instruções no artigo Configuração Inicial do servidor com o Debian 10, incluindo um usuário não raiz sudo e o firewall habilitado para bloquear portas não essenciais. O your-server-ipv4-address se refere ao endereço IP do servidor onde você estiver hospedando seu site ou domínio. O your-server-ipv6-address se refere ao endereço IPv6 do servidor onde você estiver hospedando seu site ou domínio.
      • Um nome de domínio devidamente registrado com o DNS hospedado por um provedor compatível. Este tutorial usará o your_domain durante todo o processo e a DigitalOcean como a provedora de serviço.
      • Uma chave de API para a DigitalOcean (Token de acesso pessoal), com permissões de leitura e gravação. Para criar uma chave, acesse a página Como criar um Token de acesso pessoal.

      Assim que estiver com tudo pronto, faça login no seu servidor como usuário não raiz para começar.

      Passo 1 — Como instalar o DNSControl

      O DNSControl foi escrito em Go, de modo que você começará este passo instalando o Go em seu servidor e configurando o seu GOPATH.

      O Go está disponível dentro dos repositórios padrão de software do Debian, possibilitando que ele seja instalado com as ferramentas de gerenciamento de pacotes convencionais.

      Também será necessário instalar o Git, pois ele é necessário para permitir que o Go baixe e instale o software DNSControl a partir de seu repositório no GitHub.

      Comece atualizando o índice local de pacotes para refletir quaisquer novas alterações feitas no pacote original (upstream):

      Em seguida, instale os pacotes golang-go e git:

      • sudo apt install golang-go git

      Após confirmar a instalação, a ferramenta apt irá baixar e instalar o Go e o Git, bem como todas as suas respectivas dependências.

      Em seguida, você irá configurar as variáveis de ambiente path necessárias para o Go. Se quiser saber mais sobre isso, leia o tutorial Entendendo o GOPATH. Comece editando o arquivo ~/.profile:

      Adicione as seguintes linhas ao final do seu arquivo:

      ~/.profile

      ...
      export GOPATH="$HOME/go"
      export PATH="$PATH:$GOPATH/bin"
      

      Assim que tiver adicionado essas linhas ao final do arquivo, salve e feche o arquivo. Em seguida, recarregue seu perfil - seja fazendo log-off e fazendo log-in de volta, ou fornecendo o arquivo novamente:

      Agora que você instalou e configurou o Go, instale o DNSControl.

      O comando go get pode ser usado para obter uma cópia do código, compilá-lo automaticamente e instalá-lo dentro do seu diretório Go:

      • go get github.com/StackExchange/dnscontrol

      Assim que terminar, verifique a versão instalada para garantir que tudo está funcionando:

      Sua saída será semelhante à seguinte:

      Output

      dnscontrol 2.9-dev

      Se ver um erro dnscontrol: command not found, verifique novamente sua configuração de caminho do Go.

      Agora que você instalou o DNSControl, você pode criar um diretório de configuração e conectar o DNSControl ao seu provedor de DNS, a fim de permitir que ele faça alterações em seus registros de DNS.

      Passo 2 — Configurando o DNSControl

      Neste passo, você criará os diretórios de configuração necessários para o DNSControl e o conectará ao seu provedor de DNS para que ele possa começar a fazer alterações dinâmicas (em tempo real) nos seus registros do DNS.

      Primeiro, crie um novo diretório no qual você possa armazenar sua configuração do DNSControl e, então, vá para ele:

      • mkdir ~/dnscontrol
      • cd ~/dnscontrol

      Nota: este tutorial se concentrará na configuração inicial do DNSControl; no entanto, para o uso na produção, é recomendável armazenar sua configuração do DNSControl em um sistema de controle de versão (VCS) como o Git. As vantagens de se usar um VCS incluem o controle total de versões, integração com CI/CD para teste, reverter implantações sem interrupções e assim por diante.

      Se quiser usar o DNSControl para escrever arquivos de zona no BIND, crie também o diretório zones:

      Os arquivos de zona do BIND são um método bruto e padronizado para armazenar zonas/registros do DNS em formato de texto simples. Eles foram originalmente usados para o software de servidor de DNS BIND, mas agora são amplamente adotados como o método padrão para armazenar zonas de DNS. Os arquivos de zona no BIND produzidos pelo DNSControl são úteis caso queira importá-los para um servidor DNS personalizado ou auto-hospedado, ou para fins de auditoria.

      No entanto, se quiser usar o DNSControl para forçar alterações do DNS em um provedor gerenciado, o diretório zones não será necessário.

      Em seguida, você precisa configurar o arquivo creds.json, que é o que permitirá que o DNSControl se autentique para seu provedor DNS e faça as alterações. O formato creds.json difere ligeiramente, dependendo do provedor de DNS que você estiver usando. Para encontrar a configuração do seu próprio provedor, consulte a Lista de provedores de serviço na documentação oficial do DNSControl.

      Crie o arquivo creds.json no diretório ~/dnscontrol:

      • cd ~/dnscontrol
      • nano creds.json

      Adicione a configuração do creds.json do exemplo para o seu provedor de DNS ao arquivo. Se estiver usando o DigitalOcean como seu provedor fr DNS, você pode usar o seguinte:

      ~/dnscontrol/creds.json

      {
      "digitalocean": {
        "token": "your-digitalocean-oauth-token"
      }
      }
      

      Esse arquivo diz ao DNSControl com quais provedores de DNS você quer que ele se conecte.

      Você precisará fornecer alguma forma de autenticação para seu provedor de DNS. Normalmente, essa autenticação consiste em uma chave de API ou token do OAuth, mas alguns provedores exigem informações extra, conforme documentado na Lista de provedores de serviço na documentação oficial do DNSControl.

      Aviso: esse token dará acesso à conta do seu provedor de DNS; dessa maneira, você deve protegê-lo, do mesmo modo que faria com uma senha. Além disso, se você estiver usando um sistema de controle de versão, certifique-se de que o arquivo que contém o token seja excluído (por exemplo, usando o .gitignore) ou criptografado de maneira segura.

      Se estiver usando o DigitalOcean como seu provedor de DNS, você pode usar o token do OAuth necessário em suas configurações de conta do DigitalOcean que você gerou como parte dos pré-requisitos.

      Se você tiver vários provedores de DNS — por exemplo, para nomes de domínios múltiplos, ou zonas de DNS delegadas—você pode definir todos eles no mesmo arquivo creds.json.

      Você definiu os diretórios de configuração inicial do DNSControl e configurou o creds.json para permitir que o DNSControl autentique seu provedor de DNS e faça alterações. Em seguida, você criará a configuração para suas zonas de DNS.

      Passo 3 — Criando um arquivo de configuração de DNS

      Neste passo, você criará um arquivo de configuração inicial do DNS, o qual terá os registros de DNS relacionados ao seu nome de domínio ou à zona de DNS delegada.

      O dnsconfig.js é o arquivo principal de configuração de DNS para o DNSControl. Neste arquivo, as zonas de DNS e seus registros correspondentes são definidos usando a sintaxe do JavaScript. Isso é conhecido como DSL, ou Linguagem Específica de Domínio. A página de DSL do JavaScript - na documentação oficial do DNSControl, fornece mais detalhes.

      Para começar, crie o arquivo de configuração do DNS no diretório ~/dnscontrol:

      • cd ~/dnscontrol
      • nano dnsconfig.js

      Então, adicione a seguinte configuração de exemplo ao arquivo:

      ~/dnscontrol/dnsconfig.js

      // Providers:
      
      var REG_NONE = NewRegistrar('none', 'NONE');
      var DNS_DIGITALOCEAN = NewDnsProvider('digitalocean', 'DIGITALOCEAN');
      
      // Domains:
      
      D('your_domain', REG_NONE, DnsProvider(DNS_DIGITALOCEAN),
        A('@', 'your-server-ipv4-address')
      );
      

      Esse arquivo de exemplo define um nome de domínio ou uma zona de DNS em um provedor em particular que, neste caso, é o your_domain, hospedado pelo DigitalOcean. Um registro de exemplo A também é definido para a zona raiz (@), que aponta para o endereço de IPv4 do servidor no qual você está hospedando seu domínio/site.

      Existem três funções principais que constituem um arquivo de configuração básica de DNSControl:

      • NewRegistrar(name, type, metadata): define o registrador de domínios para o seu nome de domínio. O DNSControl pode usar esse registrador para fazer as alterações necessárias, como modificar os servidores de nomes autorizados. Se quiser usar o DNSControl somente para gerenciar suas zonas de DNS, isso geralmente pode ser deixado como NONE.

      • NewDnsProvider(name, type, metadata)​​​: define um provedor de serviços de DNS para seu nome de domínio ou zona delegada. É aqui que o DNSControl irá forçar as alterações do DNS que você fez.

      • D(name, registrar, modifiers): define um nome de domínio ou zona de DNS delegada para o DNSControl gerenciar, além dos registros de DNS presentes na zona.

      Você deve configurar o NewRegistrar(), o NewDnsProvider() e o D(), conforme for o caso, usando a Lista de provedores de serviços da documentação oficial do DNSControl.

      Se você está usando o DigitalOcean como seu provedor de DNS e precisa ter a capacidade de fazer alterações no DNS (e não em servidores de nome autorizados), o exemplo do bloco de código anterior já está correto.

      Assim que terminar, salve e feche o arquivo.

      Neste passo, você definiu um arquivo de configuração de DNS para o DNSControl, com os fornecedores relevantes definidos. Em seguida, você irá preencher o arquivo com alguns registros úteis de DNS.

      Passo 4 — Preenchendo seu arquivo de configuração de DNS

      Na sequência, você pode preencher o arquivo de configuração de DNS com registros de DNS úteis para o seu site ou serviço, usando a sintaxe do DNSControl.

      Ao contrário dos arquivos tradicionais de zona no BIND, nos quais os registros de DNS são escritos em um formato bruto, linha por linha, os registros DNS dentro do DNSControl são definidos como um parâmetro de função (modificador de domínio) para a função D(), como mostrado brevemente no Passo 3.

      Existe um modificador de domínio para cada um dos tipos de registro padrão de DNS, incluindo A, AAAA, MX, TXT, NS, CAA e assim por diante. Na seção de Modificadores de domínios, da documentação sobre o DNSControl, você encontra uma lista completa dos tipos de registro disponíveis.

      Os modificadores de registros individuais também estão disponíveis (modificadores de registro). Atualmente, eles são usados principalmente para definir a vida útil (TTL ou time to live) de registros individuais. Você encontra a lista completa dos modificadores de registros disponíveis na seção de Modificadores de registro da documentação sobre o DNSControl. Os modifiers de registro são opcionais e, na maioria dos casos de uso básico, podem ser deixados de fora.

      A sintaxe para definir registros de DNS varia ligeiramente em relação a cada tipo de registro. Em seguida, temos alguns exemplos dos tipos de registros mais comuns:

      • Registros do tipo A:

        • Objetivo: apontar para um endereço de IPv4.
        • Sintaxe: A('name', 'address', optional record modifiers)​​​
        • Exemplo: A('@', 'your-server-ipv4-address', TTL(30))
      • Registros do tipo AAAA:

        • Objetivo: apontar para um endereço de IPv6.
        • Sintaxe: AAAA('name', 'address', optional record modifiers)
        • Exemplo: AAAA('@', 'your-server-ipv6-address') (modificador de registro deixado de lado para que a vida útil (TTL) padrão seja usada)
      • Registros do tipo CNAME:

        • Objetivo: transformar o seu domínio/subdomínio em alias de outro.
        • Sintaxe: CNAME('name', 'target', optional record modifiers)
        • Exemplo: CNAME('subdomain1', 'example.org.') (note que um ponto final, ., deve ser incluído se houver pontos no valor)
      • Registros do tipo MX:

        • Objetivo: direcionar e-mails para servidores/endereços específicos.
        • Sintaxe: MX('name', 'priority', 'target', optional record modifiers)
        • Exemplo: MX('@', 10, 'mail.example.net') (note que um ponto final, ., deve ser incluído se houver pontos no valor)
      • Registros do tipo TXT:

        • Objetivo: adicionar texto simples arbitrário, frequentemente usado para configurações sem seu próprio tipo de registro dedicado.
        • Sintaxe: TXT('name', 'content', optional record modifiers)
        • Exemplo: TXT('@', 'This is a TXT record. ')​​​
      • Registros do tipo CAA:

        • Objetivo: restringir e informar sobre as Autoridades de Certificação (CAs) que poderão emitir os certificados de TLS para os seus domínios/subdomínios.
        • Sintaxe: CAA('name', 'tag', 'value', optional record modifiers)
        • Exemplo: CAA('@', 'issue', 'letsencrypt.org')

      Para começar a adicionar registros de DNS ao seu domínio ou zona de DNS delegada, edite seu arquivo de configuração de DNS:

      Em seguida, você pode começar a preencher os parâmetros da função D() existente, usando a sintaxe descrita na lista anterior, além da seção de Modificadores de domínios da documentação oficial sobre DNSControl. Uma vírgula (,) deve ser usada entre cada registro.

      A título de referência, este bloco de código contém um exemplo da configuração completa de uma definição básica, inicial do DNS:

      ~/dnscontrol/dnsconfig.js

      ...
      
      D('your_domain', REG_NONE, DnsProvider(DNS_DIGITALOCEAN),
        A('@', 'your-server-ipv4-address'),
        A('www', 'your-server-ipv4-address'),
        A('mail', 'your-server-ipv4-address'),
        AAAA('@', 'your-server-ipv6-address'),
        AAAA('www', 'your-server-ipv6-address'),
        AAAA('mail', 'your-server-ipv6-address'),
        MX('@', 10, 'mail.your_domain.'),
        TXT('@', 'v=spf1 -all'),
        TXT('_dmarc', 'v=DMARC1; p=reject; rua=mailto:abuse@your_domain; aspf=s; adkim=s;')
      );
      

      Assim que tiver completado sua configuração inicial do DNS, salve e feche o arquivo.

      Neste passo, você configurou o arquivo de configuração inicial do DNS, contendo seus registros de DNS. Em seguida, você testará a configuração e a implantará.

      Passo 5 — Testando e implantando sua configuração de DNS

      Neste passo, você executará uma verificação local da sintaxe em sua configuração de DNS e, em seguida, implantará as alterações no servidor/provedor ativo de DNS.

      Primeiro, vá até seu diretório dnscontrol:

      Em seguida, utilize a função preview do DNSControl para verificar a sintaxe do seu arquivo e mostrar quais alterações ele irá fazer (sem realmente fazer as alterações):

      Se a sintaxe do seu arquivo de configuração do DNS estiver correta, o DNSControl mostrará um panorama das alterações que ele irá fazer. Isso deve ser semelhante ao seguinte:

      Output

      ******************** Domain: your_domain ----- Getting nameservers from: digitalocean ----- DNS Provider: digitalocean...8 corrections #1: CREATE A your_domain your-server-ipv4-address ttl=300 #2: CREATE A www.your_domain your-server-ipv4-address ttl=300 #3: CREATE A mail.your_domain your-server-ipv4-address ttl=300 #4: CREATE AAAA your_domain your-server-ipv6-address ttl=300 #5: CREATE TXT _dmarc.your_domain "v=DMARC1; p=reject; rua=mailto:abuse@your_domain; aspf=s; adkim=s;" ttl=300 #6: CREATE AAAA www.your_domain your-server-ipv6-address ttl=300 #7: CREATE AAAA mail.your_domain your-server-ipv6-address ttl=300 #8: CREATE MX your_domain 10 mail.your_domain. ttl=300 ----- Registrar: none...0 corrections Done. 8 corrections.

      Se ver um aviso de erro em sua saída, o DNSControl dará detalhes sobre o que está errado e onde o erro está localizado dentro do seu arquivo.

      Aviso: o próximo comando fará alterações dinâmicas nos seus registros do DNS e possivelmente em outras configurações. Certifique-se de que esteja preparado para isso, incluindo fazendo um um backup da sua configuração de DNS existente, além de garantir que tenha os meios para reverter o processo, se necessário.

      Por fim, você pode enviar as alterações para seu provedor de DNS ativo:

      Você verá uma saída similar à seguinte:

      Output

      ******************** Domain: your_domain ----- Getting nameservers from: digitalocean ----- DNS Provider: digitalocean...8 corrections #1: CREATE TXT _dmarc.your_domain "v=DMARC1; p=reject; rua=mailto:abuse@your_domain; aspf=s; adkim=s;" ttl=300 SUCCESS! #2: CREATE A your_domain your-server-ipv4-address ttl=300 SUCCESS! #3: CREATE AAAA your_domain your-server-ipv6-address ttl=300 SUCCESS! #4: CREATE AAAA www.your_domain your-server-ipv6-address ttl=300 SUCCESS! #5: CREATE AAAA mail.your_domain your-server-ipv6-address ttl=300 SUCCESS! #6: CREATE A www.your_domain your-server-ipv4-address ttl=300 SUCCESS! #7: CREATE A mail.your_domain your-server-ipv4-address ttl=300 SUCCESS! #8: CREATE MX your_domain 10 mail.your_domain. ttl=300 SUCCESS! ----- Registrar: none...0 corrections Done. 8 corrections.

      Agora, se verificar as configurações de DNS do seu domínio no painel de controle do DigitalOcean, verá as alterações.

      Captura de tela do painel de controle do DigitalOcean, que mostra algumas alterações do DNS, feitas pelo DNSControl.

      Também é possível verificar a criação de registros, executando uma consulta de DNS em relação à sua zona de domínio/delegada usando o dig.

      Se não tiver o dig instalado, será necessário instalar o pacote dnsutils:

      • sudo apt install dnsutils

      Assim que instalar o dig, utilize-o para fazer uma pesquisa de DNS em relação ao seu domínio. Você verá que os registros foram atualizados de forma adequada:

      Você verá uma saída que mostra o endereço IP e o registro relevante de DNS da sua zona - que foi implantado usando o DNSControl. Os registros de DNS podem levar algum tempo para se propagarem, assim, talvez seja necessário esperar e executar esse comando novamente.

      Neste passo final, você executou uma verificação da sintaxe local do arquivo de configuração do DNS. Em seguida, implantou-a em seu provedor de DNS ativo e testou se as alterações foram feitas com êxito.

      Conclusão

      Neste artigo, você configurou o DNSControl e implantou uma configuração de DNS em um provedor ativo. Agora, você pode gerenciar e testar suas alterações de configuração do DNS em um ambiente seguro e offline, antes de implantá-las na produção.

      Se quiser explorar mais esse assunto, o DNSControl foi criado para se integrar ao seu pipeline de CI/CD (Integração Contínua/Entrega Contínua), o que lhe permite executar testes em profundidade e ter mais controle sobre sua implantação na produção. Você também pode pesquisar sobre a integração do DNSControl aos seus processos de compilação/implantação de infraestrutura, o que permite implantar servidores e adicioná-los ao DNS de maneira completamente automática.

      Se quiser avançar ainda mais com o DNSControl, os artigos do DigitalOcean, a seguir, apresentam alguns passos subsequentes interessantes para ajudar a integrar o DNSControl aos fluxos de trabalho de gerenciamento de alterações e implantação de infraestrutura:



      Source link

      Como implantar e gerenciar seu DNS usando o OctoDNS no Debian 10


      O autor selecionou a Fundação Electronic Frontier para receber uma doação como parte do programa Write for DOnations.

      Introdução

      O OctoDNS é uma ferramenta de infraestrutura como código que permite que você implante e gerencie suas zonas de DNS usando princípios de desenvolvimento de software padrão, incluindo o controle, teste e implantação automatizada de versões. O OctoDNS foi criado pelo GitHub e está escrito em Python.

      O OctoDNS elimina muitas das armadilhas do gerenciamento manual de DNS, já que os arquivos da zona ficam armazenados em um formato estruturado (YAML). Isso permite que você implante zonas para vários provedores de DNS simultaneamente, identifique erros de sintaxe e envie a configuração do DNS automaticamente, reduzindo o risco de erro humano. Outro uso comum do OctoDNS é o de sincronizar sua configuração do DNS entre diferentes provedores, como um sistema de teste e de produção, ou entre ambientes ativos e de failover.

      O OctoDNS é parecido com o DNSControl, que é uma ferramenta equivalente criada pelo Stack Exchange e escrita em Go. Diferente do OctoDNS, o DNSControl utiliza uma linguagem de configuração baseada em JavaScript para definir as zonas de DNS, o que permite que você utilize recursos de programação avançados, tais como os loops para especificar vários registros semelhantes dentro da mesma zona. O artigo Como implantar e gerenciar seu DNS usando o DNSControl no Debian 10 aborda a instalação e configuração básicas do DNSControl.

      Neste tutorial, você instalará e configurará o OctoDNS, criará uma configuração básica do DNS e começará a implantar os registros do DNS em um provedor ativo. Como parte deste tutorial, usaremos a DigitalOcean como a provedora de DNS do exemplo. Se quiser usar um provedor diferente, a configuração é bastante parecida. Quando tiver concluído a configuração, você conseguirá gerenciar e testar sua configuração de DNS em um ambiente seguro e off-line e, então, poderá implantá-lo na produção.

      Pré-requisitos

      Antes de iniciar este guia, será necessário o seguinte:

      • Um servidor Debian 10 configurado, de acordo com o artigo Configuração Inicial do servidor com o Debian 10, incluindo um usuário não raiz do comando sudo e um firewall habilitado para bloquear portas não essenciais. O your-server-ipv4-address e o your-server-ipv6-address referem-se ao endereço IP do servidor onde você estiver hospedando seu site ou domínio.
      • Um nome de domínio totalmente registrado com o DNS hospedado por um provedor compatível. Este tutorial usará o your-domain durante todo o processo e a DigitalOcean como a provedora de serviços.
      • Uma chave de API para a DigitalOcean (Token de acesso pessoal), com permissões de leitura e gravação. Para criar um chave, acesse a página do artigo sobre Como criar um Token de acesso pessoal.

      Assim que estiver com tudo pronto, faça login no seu servidor como usuário não raiz para começar.

      Passo 1 — Instalando o OctoDNS

      O OctoDNS é distribuído como um pacote pip (sistema de gerenciamento de pacotes) em Python e funciona em um Ambiente Virtual Python (virtualenv). Dessa maneira, você iniciará este passo instalando os pacotes necessários para isso. Um virtualenv é um ambiente Python isolado que pode ter suas próprias bibliotecas e configuração, separado da instalação de Python do sistema principal. O Python e o virtualenv estão disponíveis dentro dos repositórios padrão de software do Debian, possibilitando que eles sejam instalados com as ferramentas convencionais de gerenciamento de pacotes.

      Comece atualizando o índice de pacotes local para refletir quaisquer novas alterações feitas no pacote original:

      Então, instale os pacotes python e virtualenv:

      • sudo apt install python virtualenv

      Após confirmar a instalação, a ferramenta apt irá baixar e instalar o Python, o virtualenv e todas as suas dependências necessárias.

      Em seguida, você criará os diretórios necessários para o OctoDNS, onde sua configuração do DNS e do programa serão armazenados. Comece criando os diretórios ~/octodns e ~/octodns/config:

      • mkdir ~/octodns ~/octodns/config

      Agora, vá para ~/octodns:

      Em seguida, você precisará criar o Ambiente Virtual em Python — um ambiente Python isolado com suas próprias bibliotecas e configuração no qual irá executar o OctoDNS:

      Ative seu ambiente com o seguinte comando:

      Isso irá gerar algo parecido com o seguinte:

      Output

      Running virtualenv with interpreter /usr/bin/python2 New python executable in /home/user/octodns/env/bin/python2 Also creating executable in /home/user/octodns/env/bin/python Installing setuptools, pkg_resources, pip, wheel...done.

      Agora, seu prompt de shell no Bash também será prefixado com o nome do ambiente virtual. Isso mostra que você está operando dentro do virtualenv no momento:

      (env) user@digitalocean:~/octodns$
      

      Se quiser sair do virtualenv, utilize o comando deactivate a qualquer momento. No entanto, para continuar com este tutorial, você deve permanecer em seu virtualenv.

      Agora que você instalou e configurou o Python e o virtualenv, instale o OctoDNS. O OctoDNS é distribuído como um pacote pip do Python, que é a ferramenta padrão de gerenciamento de pacotes para pacotes e bibliotecas do Python.

      Você pode instalar o pacote pip do OctoDNS usando o seguinte comando dentro do seu virtualenv:

      Assim que terminar, verifique a versão instalada para garantir que tudo está funcionando:

      Sua saída será semelhante à seguinte:

      Output

      octoDNS 0.9.9

      Caso veja um erro octodns-sync: command not found, verifique novamente se você ainda está dentro do seu virtualenv.

      Agora que você instalou o OctoDNS, você pode criar os arquivos de configuração necessários para conectar o OctoDNS ao seu provedor de DNS para permitir que ele faça alterações nos seus registros de DNS.

      Passo 2 — Configurando o OctoDNS

      Neste passo, você criará os arquivos de configuração necessários para o OctoDNS e conectará ele ao seu provedor DNS, de modo que ele possa começar a fazer alterações em tempo real nos seus registros de DNS.

      Nota: este tutorial se concentrará na configuração inicial do OctoDNS; no entanto, para o uso na produção, é recomendável armazenar sua configuração do OctoDNS em um sistema de controle de versão (VCS) como o Git. As vantagens de se usar um VCS incluem o controle total de versões, integração com CI/CD para teste, reverter implantações sem interrupções e assim por diante.

      Primeiro, você precisa configurar o arquivo config.yaml, o qual define as zonas de DNS a serem gerenciadas pelo OctoDNS e permite que ele autentique seu provedor de DNS e faça alterações.

      Dependendo do provedor de DNS que você estiver usando o formado do arquivo config.yaml será ligeiramente diferente. Para encontrar a configuração para o seu provedor, consulte a Lista de provedores compatíveis na documentação oficial do OctoDNS. Ao visualizar esse hiperlink, os detalhes da configuração serão apresentados como comentários de código no código Python em si, que está vinculado na coluna ‘Provedor’ da tabela. Assim que tiver encontrado o código Python para o seu provedor, como o cloudflare.py ou o route53.py, o comentário de código relevante poderá ser encontrado diretamente sob a class ProviderNameProvider. Por exemplo:

      Excerpt of octodns/provider/route53.py

      class Route53Provider(BaseProvider):
        '''
        AWS Route53 Provider
        route53:
            class: octodns.provider.route53.Route53Provider
            # The AWS access key id
            access_key_id:
            # The AWS secret access key
            secret_access_key:
            # The AWS session token (optional)
            # Only needed if using temporary security credentials
            session_token:
      

      Vá para o diretório ~/octodns/config:

      Então, crie e abra o config.yaml para a edição:

      Adicione a configuração de exemplo do arquivo config.yaml do seu provedor de DNS ao arquivo. Se estiver usando a DigitalOcean como sua provedora de DNS, você pode usar o seguinte:

      ~/octodns/config/config.yaml

      ---
      providers:
        config:
          class: octodns.provider.yaml.YamlProvider
          directory: ./config
          default_ttl: 300
          enforce_order: True
        digitalocean:
          class: octodns.provider.digitalocean.DigitalOceanProvider
          token: your-digitalocean-oauth-token
      
      zones:
        your-domain.:
          sources:
            - config
          targets:
            - digitalocean
      

      Esse arquivo diz ao OctoDNS a quais provedores de DNS você quer que ele se conecte e quais zonas do DNS ele deve gerenciar em relação a esses provedores.

      Você precisará fornecer alguma forma de autenticação para seu provedor de DNS. Normalmente, trata-se de uma chave de API ou de token do OAth.

      Se não quiser armazenar seu token de acesso em texto simples no arquivo de configuração, em vez disso, você pode enviá-lo como uma variável de ambiente quando o programa for executado. Para fazer isso, você deve usar a seguinte linha de token: em vez de no arquivo config.yaml:

      ~/octodns/config/config.yaml

      token: env/DIGITALOCEAN_OAUTH_TOKEN
      

      Em seguida, antes de executar o OctoDNS, defina a variável de ambiente relevante para o seu token de acesso e o OctoDNS o lerá a partir daí quando for executado:

      • export DIGITALOCEAN_OAUTH_TOKEN=your-digitalocean-oauth-token

      Aviso: este token dará acesso à sua conta do provedor de DNS; portanto, você deve protegê-lo, assim como faria com uma senha. Além disso, se você estiver usando um sistema de controle de versão, certifique-se de que o arquivo que contém o token seja excluído (por exemplo, usando o .gitignore) ou criptografado de maneira segura.

      Se estiver usando a DigitalOcean como sua provedora de DNS, você pode usar o token do OAuth necessário - gerado como parte dos pré-requisitos - em suas configurações de conta da DigitalOcean.

      Se você tiver vários provedores de DNS — por exemplo, para vários nomes de domínios, ou zonas de DNS delegadas — você pode definir todos eles no mesmo arquivo config.yaml.

      Você configurou o arquivo de configuração inicial do OctoDNS para permitir que o programa autentique o seu provedor de DNS e faça alterações. Em seguida, você criará a configuração para suas zonas de DNS.

      Passo 3 — Criando um arquivo de configuração de DNS

      Neste passo, você criará um arquivo de configuração inicial do DNS, que terá os registros de DNS para seu nome de domínio ou zona de DNS delegada.

      Cada zona de DNS que você quiser gerenciar usando o OctoDNS tem seu próprio arquivo, por exemplo your-domain.yaml​​​​. Nesse arquivo, os registros de DNS para a zona são definidos com o YAML.

      Para começar, vá para o diretório ~/octodns/config:

      Então, crie e abra o your-domain.yaml para a edição:

      Adicione a seguinte configuração de exemplo ao arquivo:

      ~/octodns/config/your-domain.yaml

      ---
      '':
        - type: A
          value: your-server-ipv4-address
      
      www:
        - type: A
          value: your-server-ipv4-address
      

      Esse arquivo de exemplo define uma zona de DNS para o your-domain com dois registros do tipo A, apontando para o endereço IPv4 em que você está hospedando seu domínio ou site. Um registro do tipo A é para o domínio raiz (por exemplo, your-domain) e o outro registro A é para o subdomínio www (por exemplo, www.your-domain).

      Assim que terminar, salve e feche o arquivo.

      Você configurou um arquivo básico de configuração de zona de DNS para o OctoDNS, com dois registros tipo A básicos apontando para o endereço IPv4 do seu domínio ou site. Em seguida, você irá expandir arquivo com alguns registros úteis de DNS.

      Passo 4 — Preenchendo seu arquivo de configuração de DNS

      Em seguida, você pode preencher o arquivo de configuração do DNS com um conjunto prático de registros de DNS para o seu site ou serviço, usando a linguagem de configuração estruturada YAML.

      Diferente dos arquivos da zona BIND tradicionais, onde os registros DNS estão escritos em um formato bruto, linha a linha, os registros de DNS dentro do OctoDNS são definidos como chaves e subchaves em YAML, com um número de valores associados, como mostrado rapidamente no Passo 3.

      Normalmente, a chave de nível superior é a 'name', que é essencialmente, o identificador do registro. www, subdomain1 e mail são todos exemplos do DNS 'name'. No OctoDNS, existem dois nomes para uso especial, que são '', para o registro raiz (geralmente referido como @) e '*', para registros curinga. O type é um valor necessário de cada chave (registro de DNS). Isso define qual tipo de registro de DNS você está definindo dentro daquela chave de nível superior em YAML. Existe um type para cada um dos tipos padrão de registro de DNS, incluindo A, AAAA, MX, TXT, NS, CNAME e assim por diante. Na seção de Registros da documentação do OctoDNS, você encontra uma lista completa dos tipos de registro disponíveis.

      Os valores dos seus registros de DNS são definidos diretamente - como valores para as chaves de nível superior (se tiver apenas um valor), ou como uma lista (se tiver vários valores como, por exemplo, múltiplos endereços IP ou MX).

      Por exemplo, para definir um único valor, você poderia usar a seguinte configuração:

      ~/octodns/config/your-domain.yaml

      'www':
        type: A
        value: 203.0.113.1
      

      Como alternativa, para definir vários valores para um único registro:

      ~/octodns/config/your-domain.yaml

      'www':
        type: A
        values:
        - 203.0.113.1
        - 203.0.113.2
      

      A sintaxe para definir registros de DNS varia ligeiramente para cada tipo de registro. Em seguida, temos alguns exemplos dos tipos de registro mais comuns:

      Registros do tipo A:

      Objetivo: apontar para um endereço IPv4.

      Sintaxe:

      'name':
        type: A
        value: ipv4-address
      

      Exemplo:

      'www':
        type: A
        value: your-server-ipv4-address
      

      Registros do tipo AAAA:

      Objetivo: apontar para um endereço IPv6.

      Sintaxe:

      'name':
        type: AAAA
        value: ipv6-address
      

      Exemplo:

      'www':
        type: AAAA
        value: your-server-ipv6-address
      

      Registros do tipo CNAME:

      Objetivo: transformar o seu domínio/subdomínio em alias de outro.

      Sintaxe:

      'name':
        type: CNAME
        value: fully-qualified-domain-name
      

      Exemplo:

      'www':
        type: CNAME
        value: www.example.org
      

      Registros do tipo MX:

      Objetivo: direcionar e-mails para servidores/endereços específicos.

      Sintaxe:

      'name':
        type: MX
        value:
          exchange: mail-server
          preference: priority-value
      

      Note que um ponto final, ., *deve *ser incluído se houver quaisquer pontos no valor do registro tipo MX.

      Exemplo:

      '':
        type: MX
        value:
          exchange: mail.your-domain.
          preference: 10
      

      Registros do tipo TXT:

      Objetivo: adicionar texto simples arbitrário, frequentemente usado para configurações sem seu próprio tipo de registro dedicado.

      Sintaxe:

      'name':
        type: TXT
        value: content
      

      Exemplo:

      '':
        type: TXT
        value: This is a TXT record.
      

      Para começar a adicionar registros de DNS ao seu domínio ou zona de DNS delegada, edite seu arquivo de configuração de DNS:

      • cd ~/octodns/config
      • nano your-domain.yaml

      Na sequência, você pode começar a preencher sua zona de DNS, usando a sintaxe descrita na lista anterior, bem como a seção de Registros da documentação oficial do OctoDNS.

      A título de referência, este bloco de código contém um exemplo da configuração completa de uma definição básica, inicial do DNS:

      ~/octodns/config/your-domain.yaml

      ---
      '':
        - type: A
          value: your-server-ipv4-address
      
        - type: AAAA
          value: your-server-ipv6-address
      
        - type: MX
          value:
            exchange: mail.your-domain.
            preference: 10
      
        - type: TXT
          value: v=spf1 -all
      
      _dmarc:
        type: TXT
        value: v=DMARC1; p=reject; rua=mailto:abuse@your-domain; aspf=s; adkim=s;
      
      mail:
        - type: A
          value: your-server-ipv4-address
      
        - type: AAAA
          value: your-server-ipv6-address
      
      www:
        - type: A
          value: your-server-ipv4-address
      
        - type: AAAA
          value: your-server-ipv6-address
      

      Assim que tiver completado sua configuração inicial de DNS, salve e feche o arquivo.

      Neste passo, você configurou o arquivo de configuração inicial do DNS, contendo seus registros de DNS. Em seguida, você testará a configuração e a implantará.

      Passo 5 — Testando e implantando sua configuração de DNS

      Neste passo, você executará uma verificação local da sintaxe em sua configuração de DNS e, em seguida, implantará as alterações no servidor/provedor ativo de DNS.

      Primeiro, vá até seu diretório octodns:

      Verifique novamente se você ainda está operando dentro do seu virtualenv em Python, procurando por seu nome, antes do prompt do Bash:

      (env) user@digitalocean:~/octodns$
      

      Em seguida, utilize o comando octodns-validate para verificar a sintaxe do(s) seu(s) arquivo(s) de configuração. Você precisará especificar o caminho para seu arquivo de configuração:

      • octodns-validate --config=./config/config.yaml

      Se a sintaxe YAML do seu arquivo de configuração DNS estiver correta, o OctoDNS não retornará nenhum resultado. Se ver um erro ou um aviso em seu resultado, o OctoDNS dará detalhes sobre o que está errado e onde o erro está localizado dentro do seu arquivo YAML.

      Em seguida, você pode realizar um push de simulação da configuração do DNS, que irá exibir quais alterações serão feitas, sem, de fato, fazê-las:

      • octodns-sync --config=./config/config.yaml

      Isso deve gerar uma saída parecida com esta:

      Output

      ******************************************************************************** * your-domain. ******************************************************************************** * digitalocean (DigitalOceanProvider) * Create <ARecord A 300, mail.your-domain., ['your-server-ipv4-address']> (config) * Create <AaaaRecord AAAA 300, mail.your-domain., ['your-server-ipv6-address']> (config) * Create <TxtRecord TXT 300, your-domain., ['v=spf1 -all']> (config) * Create <AaaaRecord AAAA 300, your-domain., ['your-server-ipv6-address']> (config) * Create <ARecord A 300, your-domain., ['your-server-ipv4-address']> (config) * Create <ARecord A 300, www.your-domain., ['your-server-ipv4-address']> (config) * Create <MxRecord MX 300, your-domain., [''10 mail.your-domain.'']> (config) * Create <TxtRecord TXT 300, _dmarc.your-domain., ['v=DMARC1; p=reject; rua=mailto:abuse@your-domain; aspf=s; adkim=s;']> (config) * Create <AaaaRecord AAAA 300, www.your-domain., ['your-server-ipv6-address']> (config) * Summary: Creates=9, Updates=0, Deletes=0, Existing Records=2 ********************************************************************************

      Aviso: o próximo comando fará alterações em tempo real nos seus registros de DNS e, possivelmente, em outras configurações. Certifique-se de que esteja preparado para isso, incluindo a realização de um backup da sua configuração de DNS existente, além de garantir que tenha os meios para reverter o processo, se necessário.

      Por fim, você pode enviar as alterações para seu provedor de DNS ativo:

      • octodns-sync --config=./config/config.yaml --doit

      Nota: em alguns casos, o OctoDNS se recusará a forçar alterações se estiver fazendo um número significativo de ajustes. Trata-se de um recurso de proteção automático feito para evitar erros de configuração acidentais. Se ocorrer essa recusa, tente executar novamente o octodns-sync usando a opção --force, mas certifique-se de que esteja pronto para fazer isso.

      Neste passo, você verá uma saída similar à simulação anterior, mas com a adição de algo parecido com o seguinte:

      Output

      2019-07-07T23:17:27 INFO DigitalOceanProvider[digitalocean] apply: making changes 2019-07-07T23:17:30 INFO Manager sync: 9 total changes

      Agora, se verificar as configurações de DNS do seu domínio no painel de controle da DigitalOcean, verá as alterações.

      Captura de tela do painel de controle da DigitalOcean, que mostra algumas alterações do DNS, feitas pelo OctoDNS.

      Também é possível verificar a criação de registros, executando uma consulta de DNS em relação à sua zona de domínio/delegada usando o dig.

      Se não tiver o dig instalado, será necessário instalar o pacote dnsutils:

      • sudo apt install dnsutils

      Assim que instalar o dig, utilize-o para fazer uma pesquisa de DNS em relação ao seu domínio. Você verá que os registros foram devidamente atualizados:

      Você verá uma saída que mostra o endereço IP e o registro relevante de DNS da sua zona - que foi implantado usando o OctoDNS. Os registros de DNS podem levar algum tempo para se propagarem; assim, talvez seja necessário esperar e executar esse comando novamente.

      Neste passo final, você executou uma verificação da sintaxe local do arquivo de configuração do DNS. Em seguida, implantou-a em seu provedor de DNS ativo e testou se as alterações foram feitas com êxito.

      Conclusão

      Neste artigo, você configurou o OctoDNS e implantou uma configuração de DNS em um provedor ativo. Agora, você pode gerenciar e testar suas alterações de configuração do DNS em um ambiente seguro e off-line, antes de implantá-las na produção.

      Se quiser explorar mais esse assunto, o OctoDNS foi criado para se integrar ao seu pipeline de CI/CD (Integração Contínua/Entrega Contínua), o que lhe permite executar testes em profundidade e ter mais controle sobre sua implantação na produção. Você também pode pesquisar sobre a integração do OctoDNS aos seus processos de compilação/implantação de infraestrutura, o que permite implantar servidores e adicioná-los ao DNS de maneira completamente automática.

      Se quiser saber mais sobre o OctoDNS, os artigos da DigitalOcean a seguir fornecem alguns passos interessantes para ajudar a integrar o OctoDNS em seus fluxos de trabalho de gerenciamento de mudanças e implantação de infraestrutura:



      Source link