Como implantar o Apache Airflow no Vultr usando o Anaconda – SitePoint

Neste artigo, vamos implantar um aplicativo de fluxo de ar em um ambiente do CONDA e proteger o aplicativo usando o NGINX e solicitar o certificado SSL da Let’s Encrypt.

Fluxo de ar é uma ferramenta popular que podemos usar para definir, agendar e monitorar nossos fluxos de trabalho complexos. Podemos criar gráficos acíclicos direcionados (DAGs) para automatizar tarefas em nossas plataformas de trabalho e, sendo o fluxo de ar aberto, o fluxo de ar tem uma comunidade para fornecer suporte e melhorar continuamente.

Este é um artigo patrocinado da Vultr. A Vultr é a maior plataforma de computação em nuvem de capital privado do mundo. A favorita dos desenvolvedores, a Vultr atendeu a mais de 1,5 milhão de clientes em 185 países com soluções flexíveis, escaláveis e globais de nuvem, GPU em nuvem, metal nu e armazenamento em nuvem. Saiba mais sobre Vultr.

Implantando um servidor no Vultr

Vamos começar implantando um servidor Vultr com o aplicativo da Anaconda Marketplace.

Inscreva -se e faça login no Portal do cliente Vultr.
Navegue até a página de produtos.
Selecione Calcular No menu lateral.
Clique Implantar servidor.
Selecione Compute em nuvem como o tipo de servidor.
Escolha um Localização.
Selecione Anaconda Entre as aplicações de mercado.
Escolha um Plano.
Selecione mais recursos conforme necessário na seção “Recursos adicionais”.
Clique no Implantar agora botão.

Criando um banco de dados gerenciado pela Vultr

Depois de implantar um servidor Vultr, a seguir, implantaremos um banco de dados PostGresql gerenciado pelo Vultr. Também criaremos dois novos bancos de dados em nossa instância de banco de dados que serão usados para se conectar ao nosso aplicativo Airflow mais tarde no blog.

Abra o Portal do cliente Vultr.
Clique no Produtos grupo de menu e navegue para Bancos de dados Para criar um banco de dados gerenciado do PostgreSQL.
Clique Adicionar bancos de dados gerenciados.
Selecione PostGresql com a versão mais recente como mecanismo de banco de dados.
Selecione Configuração do servidor e Localização do servidor.
Escreva a Rótulo para o serviço.
Clique Implantar agora.
Depois que o banco de dados for implantado, selecione Usuários e bancos de dados.
Clique Adicione novo banco de dados.
Digite um nome, clique Adicionar banco de dados e nomear airflow-pgsql.
Repita as etapas 9 e 10 para adicionar outro banco de dados no mesmo banco de dados gerenciado e nomeie -o airflow-celery.

Introdução com conda e fluxo de ar

Agora que criamos uma instância do PostGresql gerenciada pelo Vultr, usaremos o servidor Vultr para criar um ambiente do CONDA e instalar as dependências necessárias.

Verifique a versão CONDA:
Crie um ambiente de conda:
```
$ conda create -n airflow python=3.8
```
Ative o ambiente:
Instale o Redis Server:
```
(airflow) $ apt install -y redis-server
```

Ativar o servidor Redis:

(airflow) $ sudo systemctl enable redis-server

Verifique o status:

(airflow) $ sudo systemctl status redis-server

Verificação de status do servidor Redis

Instale o Python Package Manager:
```
(airflow) $ conda install pip
```

Instale as dependências necessárias:

(airflow) $ pip install psycopg2-binary virtualenv redis

Instale o fluxo de ar no ambiente do CONDA:

(airflow) $ pip install "apache-airflow(celery)==2.8.1" --constraint "https://raw.githubusercontent.com/apache/airflow/constraints-2.8.1/constraints-3.8.txt"

Conectando fluxo de ar com banco de dados gerenciado Vultr

Depois de preparar o ambiente, agora vamos conectar nosso aplicativo de fluxo de ar com os dois bancos de dados que criamos anteriormente em nossa instância do banco de dados e fazer as alterações necessárias na configuração do fluxo de ar para tornar nosso aplicativo pronto para produção.

Defina a variável de ambiente para conexão com o banco de dados:
```
(airflow) $ export AIRFLOW__DATABASE__SQL_ALCHEMY_CONN="postgresql://user:password@hostname:port/db_name"
```
Certifique -se de substituir o userAssim, passwordAssim, hostnamee port com os valores reais na seção Detalhes da conexão, selecionando o airflow-pgsql banco de dados. Substitua o db_name com airflow-pgsql.
Inicialize o banco de dados de metadados.

Devemos inicializar um banco de dados de metadados para o fluxo de ar para criar tabelas e esquemas necessários que armazenam informações como DAGs e informações relacionadas aos nossos fluxos de trabalho:
```
(airflow) $ airflow db init
```
Abra o arquivo de configuração do fluxo de ar:
```
(airflow) $ sudo nano ~/airflow/airflow.cfg
```
Role para baixo e mude o executor:
```
executor = CeleryExecutor
```
Vincular o banco de dados PostGresql gerenciado pelo Vultr e altere o valor de sql_alchemy_conn:
```
sql_alchemy_conn = "postgresql://user:password@hostname:port/db_name"
```
Certifique -se de substituir o userAssim, passwordAssim, hostnamee porta com os valores reais na seção Detalhes da conexão, selecionando o airflow-pgsql banco de dados. Substitua o db_name com airflow-pgsql.

Role para baixo e altere o trabalhador e acione as portas de log:

worker_log_server_port = 8794
trigger_log_server_port = 8795

Mude o broker_url:
```
broker_url = redis://localhost:6379/0
```
Remova o # e mude o result_backend:
```
result_backend = db+postgresql://user:password@hostname:port/db_name
```
Certifique -se de substituir o userAssim, passwordAssim, hostnamee port com os valores reais na seção Detalhes da conexão, selecionando o airflow-celery banco de dados. Substitua o db_name com airflow-celery.
Salvar e sair do arquivo.
Crie um usuário do fluxo de ar:
```
(airflow) $ airflow users create \n    --username admin \n    --firstname Peter \n    --lastname Parker \n    --role Admin \n    --email spiderman@superhero.org
```
Certifique -se de substituir todos os valores variáveis pelos valores reais.

Digite uma senha quando solicitado a defini -la para o usuário enquanto acessa o painel.

Daemonizando o aplicativo de fluxo de ar

Agora, vamos daemonizar nosso aplicativo de fluxo de ar para que ele seja executado em segundo plano e continue a funcionar de forma independente, mesmo quando fechamos o terminal e logot.

Essas etapas também nos ajudarão a criar um serviço persistente para os trabalhadores do Scheduler, Scheduler e Celery.

Veja o airflow caminho:
```
(airflow) $ which airflow
```
Copie e cole o caminho para a área de transferência.

Crie um arquivo de serviço de servidor da Web para fluxo de ar:

(airflow) $ sudo nano /etc/systemd/system/airflow-webserver.service

Cole as configurações de serviço no arquivo.

airflow webserver é responsável por fornecer uma interface de usuário baseada na Web que nos permitirá interagir e gerenciar nossos fluxos de trabalho. Essas configurações farão um serviço em execução para o nosso servidor da web do fluxo de ar:
```
(Unit)
Description="Airflow Webserver"
After=network.target

(Service)
User=example_user
Group=example_user
ExecStart=/home/example_user/.local/bin/airflow webserver

(Install)
WantedBy=multi-user.target
```
Certifique -se de substituir User e Group com os detalhes da conta de usuário do sudo sem raios, e substitua o ExecStart Caminho com o caminho real do fluxo de ar, incluindo o binário executável que copiamos anteriormente na área de transferência.
Salve e feche o arquivo.
Ative o airflow-webserver Serviço, para que o servidor da web inicie automaticamente durante o processo de inicialização do sistema:
```
(airflow) $ systemctl enable airflow-webserver
```

Inicie o serviço:

(airflow) $ sudo systemctl start airflow-webserver

Certifique -se de que o serviço esteja em funcionamento:
```
(airflow) $ sudo systemctl status airflow-webserver
```
Nossa saída deve aparecer como a foto abaixo.

Crie um arquivo de serviço de aipo do fluxo de ar:

(airflow) $ sudo nano /etc/systemd/system/airflow-celery.service

Cole as configurações de serviço no arquivo.

airflow celery worker Inicia um trabalhador de aipo. O aipo é uma fila de tarefas distribuídas que nos permitirá distribuir e executar tarefas em vários trabalhadores. Os trabalhadores se conectam ao nosso servidor Redis para receber e executar tarefas:
```
(Unit)
Description="Airflow Celery"
After=network.target

(Service)
User=example_user
Group=example_user
ExecStart=/home/example_user/.local/bin/airflow celery worker

(Install)
WantedBy=multi-user.target
```
Certifique -se de substituir User e Group com os detalhes da conta de usuário do sudo sem raios, e substitua o ExecStart Caminho com o caminho real do fluxo de ar, incluindo o binário executável que copiamos anteriormente na área de transferência.
Salve e feche o arquivo.

Ative o airflow-celery serviço:

(airflow) $ sudo systemctl enable airflow-celery

Inicie o serviço:

(airflow) $ sudo systemctl start airflow-celery

Certifique -se de que o serviço esteja em funcionamento:
```
(airflow) $ sudo systemctl status airflow-celery
```

Crie um arquivo de serviço do Airflow Scheduler:

(airflow) $ sudo nano /etc/systemd/system/airflow-scheduler.service

Cole as configurações de serviço no arquivo.

airflow scheduler é responsável pelo agendamento e acionamento dos DAGs e das tarefas definidas nelas. Ele também verifica o status de DAGs e tarefas periodicamente:
```
(Unit)
Description="Airflow Scheduler"
After=network.target

(Service)
User=example_user
Group=example_user
ExecStart=/home/example_user/.local/bin/airflow scheduler

(Install)
WantedBy=multi-user.target
```
Certifique -se de substituir User e Group com os detalhes da conta de usuário do sudo sem raios, e substitua o ExecStart Caminho com o caminho real do fluxo de ar, incluindo o binário executável que copiamos anteriormente na área de transferência.
Salve e feche o arquivo.

Ative o airflow-scheduler serviço:

(airflow) $ sudo systemctl enable airflow-scheduler

Inicie o serviço:

(airflow) $ sudo systemctl start airflow-scheduler

Certifique -se de que o serviço esteja em funcionamento:
```
(airflow) $ sudo systemctl status airflow-scheduler
```
Nossa saída deve aparecer assim na foto abaixo.

Configurando o nginx como um proxy reverso

Criamos serviços persistentes para o aplicativo de fluxo de ar, então agora vamos configurar Nginx Como proxy reverso para aprimorar a segurança e a escalabilidade de nosso aplicativo, seguindo as etapas descritas abaixo.

Faça login no Portal do cliente Vultr.
Navegue até o Produtos página.
No menu lateral, expanda o Rede Desça e selecione Dns.
Clique no Adicionar domínio botão no centro.
Siga o procedimento de configuração para adicionar seu nome de domínio selecionando o endereço IP do seu servidor.
Defina os seguintes nomes de host como os servidores de nomes primários e secundários do seu domínio com o seu registrador de domínio:
- ns1.vultr.com
- ns2.vultr.com
Instale o nginx:
```
(airflow) $ apt install nginx
```
Verifique se o servidor nginx está em funcionamento:
```
(airflow) $ sudo systemctl status nginx
```
Criar um novo arquivo de configuração do host virtual nginx no sites-available diretório:
```
(airflow) $ sudo nano /etc/nginx/sites-available/airflow.conf
```
Adicione as configurações ao arquivo.

Essas configurações direcionarão o tráfego em nosso aplicativo do domínio real para o servidor de back -end em http://127.0.0.1:8080 Usando um passe de proxy:
```
server {

    listen 80;
    listen (::):80;
    server_name airflow.example.com;

    location / {
        proxy_pass http://127.0.0.1:8080;  
    }

}
```
Certifique -se de substituir airflow.example.com Com o domínio real, adicionamos no painel Vultr.
Salve e feche o arquivo.
Vincular o arquivo de configuração ao sites-enabled diretório para ativar o arquivo de configuração:
```
(airflow) $ sudo ln -s /etc/nginx/sites-available/airflow.conf /etc/nginx/sites-enabled/
```
Verifique a configuração para erros:
```
(airflow) $ sudo nginx -t
```
Nossa saída deve aparecer assim na foto abaixo.
Reinicie o nginx para aplicar alterações:
```
(airflow) $ sudo systemctl reload nginx
```
Permitir a porta HTTP 80 Através do firewall para todas as conexões de entrada:
```
(airflow) $ sudo ufw allow 80/tcp
```
Permitir a porta HTTPS 443 Através do firewall para todas as conexões de entrada:
```
(airflow) $ sudo ufw allow 443/tcp
```
Recarregue as regras do firewall para salvar alterações:
```
(airflow) $ sudo ufw reload
```

Aplicando Let’s Crypt Certificados SSL no aplicativo de fluxo de ar

O último passo é aplicar um Vamos criptografar O certificado SSL para o nosso aplicativo de fluxo de ar para que se torne muito mais seguro e salve nosso aplicativo de ataques indesejados.

Usando Snap, instale o certificado CertBot Let’s Encrypt Client:
```
(airflow) $ snap install --classic certbot
```
Obtenha um novo certificado SSL para nosso domínio:
```
(airflow) $ certbot --nginx -d airflow.example.com
```
Certifique -se de substituir airflow.example.com com nosso nome de domínio real.
E quando solicitado, digite um endereço de e -mail e pressione Y aceitar os termos let’s criptografar.
Teste que o Certificado SSL renova automaticamente após a expiração.

A renovação automática garante que nossos certificados SSL estejam atualizados, reduzindo o risco de expiração do certificado e mantendo a segurança de nosso aplicativo:
```
(airflow) $ certbot renew --dry-run
```
Use um navegador da web para abrir nosso aplicativo de fluxo de ar: https://airflow.example.com.

Quando solicitado, digite o nome de usuário e a senha que criamos anteriormente.

Ao acessar o painel, todos os DAGs serão visíveis fornecidos por padrão.

Conclusão

Neste artigo, demonstramos como criar ambientes do CONDA, implantar um aplicativo Airflow pronto para produção e melhorar o desempenho e a segurança de um aplicativo.

Source link