<?xml version="1.0" encoding="UTF-8"?><rss xmlns:dc="http://purl.org/dc/elements/1.1/" xmlns:content="http://purl.org/rss/1.0/modules/content/" xmlns:atom="http://www.w3.org/2005/Atom" version="2.0" xmlns:cc="http://cyber.law.harvard.edu/rss/creativeCommonsRssModule.html">
    <channel>
        <title><![CDATA[Stories by Pedro Sanches on Medium]]></title>
        <description><![CDATA[Stories by Pedro Sanches on Medium]]></description>
        <link>https://medium.com/@sanchesmil?source=rss-f0415d58824b------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/fit/c/150/150/1*9loW6R4Udjw8sPfFreZbMw.jpeg</url>
            <title>Stories by Pedro Sanches on Medium</title>
            <link>https://medium.com/@sanchesmil?source=rss-f0415d58824b------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Sun, 22 Nov 2026 13:33:34 GMT</lastBuildDate>
        <atom:link href="https://medium.com/@sanchesmil/feed" rel="self" type="application/rss+xml"/>
        <webMaster><![CDATA[yourfriends@medium.com]]></webMaster>
        <atom:link href="http://medium.superfeedr.com/" rel="hub"/>
        <item>
            <title><![CDATA[Apache Airflow: extração e armazenamento de Tweets]]></title>
            <link>https://medium.com/@sanchesmil/apache-airflow-extra%C3%A7%C3%A3o-e-armazenamento-de-tweets-dbd72d0c4ad9?source=rss-f0415d58824b------2</link>
            <guid isPermaLink="false">https://medium.com/p/dbd72d0c4ad9</guid>
            <category><![CDATA[pipeline]]></category>
            <category><![CDATA[api]]></category>
            <category><![CDATA[etl-pipeline]]></category>
            <category><![CDATA[airflow]]></category>
            <dc:creator><![CDATA[Pedro Sanches]]></dc:creator>
            <pubDate>Thu, 28 Dec 2023 19:31:02 GMT</pubDate>
            <atom:updated>2023-12-28T19:31:02.685Z</atom:updated>
            <content:encoded><![CDATA[<h3>Visão geral</h3><p>Neste artigo faremos a orquestração de um <em>data pipeline</em> com a ferramenta Airflow para extração e armazenamento de tweets que contenham uma palavra de interesse. Com isso, a pessoa cientista de dados terá acesso aos dados e poderá traçar análises e modelos. Para a extração dos dados, realizaremos consultas à API <a href="https://labdados.com/">https://labdados.com/</a>, a qual nos fornecerá tweets fakes. Como resultado final, criaremos um datalake local para armazenar os dados extraídos em arquivos json.</p><h3>Fluxo do pipeline de dados</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*1KgAa8jMXJEZbGb4thCTuw.jpeg" /></figure><p>Como pode ser visto na figura acima, iremos utilizar os recursos de Hook, Operator e DAG do Airflow para criar um pipeline automatizado que realiza a extração de dados de uma API que simula dados do Twitter e os armazena em um <em>data lake </em>local, para que usuários finais como cientistas de dados consigam realizar análises e gerar modelos.</p><h3>O que vamos aprender?</h3><ul><li>Executar o Airflow localmente</li><li>Configurar uma conexão HTTP</li><li>Criar operadores e hooks</li><li>Desenvolver um DAG para extração e armazenamento de tweets</li><li>Realizar requisições para a API <a href="https://labdados.com/">https://labdados.com/</a></li><li>Extrair informações no formato json</li><li>Utilizar a mecânica de resultados paginados</li><li>Armazenar dados em um datalake local</li></ul><h4>Tecnologias utilizadas</h4><ul><li>Sistema Operacional Ubuntu</li><li>Editor VS Code</li><li>Ferramenta Apache Airflow</li><li>Linguagem Python e suas libs (requests, datetime, pathlib, json)</li></ul><h3>Preparando o ambiente: Python3.9, ambiente virtual e Airflow</h3><p>Para a execução deste projeto, utilizei o Python3.9, ambiente virtual e Airflow 2.3.2. Caso você não tenha alguma dessas ferramentas instaladas, sugiro ler o seguinte artigo:</p><p><a href="https://medium.com/@sanchesmil/instalando-o-apache-airflow-no-ubuntu-3eba864882c3">https://medium.com/@sanchesmil/instalando-o-apache-airflow-no-ubuntu-3eba864882c3</a></p><h4>Criando a pasta do projeto</h4><p>Considerando que estejamos com o terminal aberto, criaremos uma nova pasta chamada “<em>proj_twitter_pipeline</em>” e acessaremos ela, conforme os comandos abaixo.</p><pre>mkdir proj_twitter_pipeline</pre><pre>cd proj_twitter_pipeline</pre><h4>Criando e ativando o ambiente virtual na pasta do projeto:</h4><p>Dentro de “<em>proj_twitter_pipeline</em>”, criaremos o ambiente virtual no qual instalaremos o <em>Airflow</em>. Como queremos utilizar o Python 3.9, nosso comando ficará assim:</p><ul><li><strong>Criando o ambiente virtual:</strong></li></ul><pre>python3.9 -m venv venv</pre><ul><li><strong>Ativando o ambiente virtual:</strong></li></ul><pre>source venv/bin/activate</pre><h4>Instalando o Airflow</h4><ul><li><strong>Criando a pasta dos arquivos Airflow:</strong></li></ul><p>Ainda no terminal, na raiz do projeto, criaremos a pasta “<em>airflow_pipeline</em>” que será responsável por armazenar todos os arquivos do Airflow. É nela que instalaremos efetivamente o Airflow.</p><pre>mkdir airflow_pipeline</pre><pre>cd airflow_pipeline</pre><p>Nossa estrutura de pastas ficou assim:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/242/1*fLKVZxkGQ_3eDuiEVKc-eg.png" /></figure><ul><li><strong>Instalando o Airflow:</strong></li></ul><p>Instalaremos o Airflow versão 2.3.2 via terminal utilizando o gerenciador de pacotes pip, do Python, conforme comando abaixo.</p><pre>pip install &#39;apache-airflow==2.3.2&#39; --constraint  &quot;https://raw.githubusercontent.com/apache/airflow/constraints-2.3.2/constraints-3.9.txt&quot;</pre><h4>Executando o Airflow</h4><ul><li><strong>Exportando a variável de ambiente AIRFLOW_HOME:</strong></li></ul><p>Antes de executarmos o Airflow, devemos exportar a variável de ambiente apontando para o diretório onde nossos arquivos do Airflow serão armazenados.</p><pre>export AIRFLOW_HOME=/home/pedro/projetos/projetos_python/proj_twitter_pipeline/airflow_pipeline</pre><ul><li><strong>Executando o Airflow:</strong></li></ul><p>O comando abaixo é responsável por iniciar alguns serviços do Airflow, dentre eles o servidor web.</p><pre>airflow standalone</pre><ul><li><strong>Acessando a interface Web do Airflow:</strong></li></ul><p>No navegador, acessaremos o servidor web no endereço “localhost:8080”, e logaremos com o usuário e senha fornecidos pelo Airflow durante sua execução no terminal.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/416/1*JJUUlxM9NXp_pjpeJMmmzQ.png" /></figure><h3>Conexões</h3><p>O Airflow permite definir conexões personalizadas para acessar ferramentas externas, como por exemplo, bancos de dados na nuvem e APIs. Isso é útil na medida em que ele retira do usuário a responsabilidade de ter que implementar manualmente essa conexão todas as vezes que precisar utilizá-la.</p><h4>Criando uma Conexão HTTP</h4><p>Nesta seção faremos a configuração de uma nova conexão do tipo Http para acessar a API que simula os dados do Twitter.</p><p>Tendo acessado a interface web do Airflow, na guia “Admin”, selecionaremos a opção “Connections” e criaremos uma nova conexão, conforme as imagens abaixo.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/265/1*d0HlLOfvdAuOITMI5Jn6WA.png" /></figure><p>Nomearemos nossa conexão como “<strong><em>twitter_default</em></strong>” no campo “<strong>Connection Id</strong>”. Selecionaremos o tipo “<em>HTTP</em>” no campo “<strong>Connection Type</strong>”, tendo em vista que faremos requisições http à API. O campo, “Description”, é opcional. No campo “<strong>Host</strong>”, colocaremos a URL base da API que simula dados do Twitter, isto é, <a href="http://labdados.com/">http://labdados.com</a>.</p><p>Dessa forma, mais genérica, caso o projeto cresça, poderemos acessar outros <em>endpoints</em> dessa API e também outras pessoas poderão fazer essa conexão e utilizá-la para propósitos diferentes.</p><p>Os campos “Schema”, “Login”, “Password”, “Port” e “Extra” não preencheremos.</p><p>Obs.: Caso estivéssemos usando a API do próprio Twitter, seria necessário informar o Token de autenticação no campo “<strong>Extra</strong>”.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/482/1*G_Aq2Ezz7N10CCShrQ7x6g.png" /></figure><p>Ao acessarmos novamente a lista de conexões, poderemos ver a conexão “<strong><em>twitter_default</em></strong>” sendo listada.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/698/1*e7A94yzxiVFByDh_jvFvFQ.png" /></figure><p>Agora, para que essa conexão seja utilizada, faz-se necessário o uso de um <strong>Hook</strong>.</p><h3>Hook</h3><p>É uma interface do Airflow utilizada para gerenciar conexões com serviços externos, como por exemplo, bancos de dados e APIs. Ele interage com a conexão informada para coletar as credenciais pré-definidas e usá-las durante a abertura e encerramento de uma sessão.</p><p>Como desejamos realizar requisições utilizando a conexão “<strong>twitter_default</strong>” criada anteriormente, utilizaremos um Hook do tipo HTTP (HttpHooK) para interagir com essa conexão.</p><h4>Criando o TwitterHook</h4><p>Dentro da pasta “airflow_pipeline” criaremos a pasta “hook” e dentro dela um novo arquivo chamado “twitter_hook.py”.</p><p>Nossa estrutura de pastas ficou assim no VS Code:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/388/1*5Dt5tb2_gwztnqQZDxGw4w.png" /></figure><h4>Criando a classe TwitterHook</h4><p>Dentro do arquivo “twitter_hook.py” definiremos a classe “TwitterHook”, a qual será responsável por se conectar à API do Twitter e realizar a extração dos dados.</p><p>Inicialmente nossa classe herda da classe HttpHook do airflow. Isso é importante porque teremos acesso a todas as mecânicas de conexão http já estruturadas pelo Airflow.</p><pre>from airflow.providers.http.hooks.http import HttpHook<br>import requests<br><br>class TwitterHook(HttpHook):<br><br>    def __init__(self, start_time, end_time, query, conn_id=None): <br>        self.start_time = start_time  <br>        self.end_time = end_time      <br>        self.query = query            <br>        self.conn_id = conn_id or &quot;twitter_default&quot;<br><br>        super().__init__(http_conn_id=self.conn_id)</pre><p>Os parâmetros “start_time”, ”end_time” e “query” do construtor serão usados na montagem da URL de consulta à API e indicam, respectivamente, a data de inicio e fim da requisição e a palavra a ser pesquisada. Eles deverão ser informados durante a instanciação da classe. O parâmetro “conn_id” é usado para informar o nome de uma conexão específica. Caso não seja informado, o valor “<strong>twitter_default</strong>” será atribuído por padrão ao atributo “conn_id”. Esse nome faz referência à conexão que criamos anteriormente na interface do Airflow. Logo em seguida, utilizamos o método “super()” para invocarmos o construtor da classe herdada “HttpHook” e passamos como parâmetro o nome da conexão definida anteriormente. Dessa forma, o HttpHook saberá o tipo da conexão e todas as outras informações necessárias para criar uma sessão.</p><p><strong>Montando a URL de consulta</strong></p><pre>def create_url(https://medium.com/self):<br>       tweet_fields = &quot;tweet.fields=author_id,conversation_id,created_at,id,in_reply_to_user_id,public_metrics,lang,text&quot;<br>       user_fields = &quot;expansions=author_id&amp;user.fields=id,name,username,created_at&quot;<br>       url_raw = f&quot;{self.base_url}/2/tweets/search/recent?query={self.query}&amp;{tweet_fields}&amp;{user_fields}&amp;start_time={self.start_time}&amp;end_time={self.end_time}&quot;<br>       return url_raw</pre><p>O método “create_url()” será o responsável por montar a URL de consulta à API do Twitter. Ele retorna uma URL preenchida. As variáveis “tweet_fields” e “user_fields” filtram os campos de tweets e de usuários que desejamos recuperar. A url final é montada utilizando o atributo “url_base” herdado da classe HttpHook. Lembrando que o valor desse atributo foi definido no campo “host” da conexão “twitter_airflow”, isto é, <a href="https://labdados.com/"><em>https://labdados.com</em></a>.</p><p><strong>Realizando a conexão</strong></p><pre>def connect_to_endpoint(self, url, session):<br>        request = requests.Request(&#39;get&#39;,url)<br>        prep = session.prepare_request(request)<br>        self.log.info(f&quot;URL: {url}&quot;)<br>        return self.run_and_check(session,prep, {})</pre><p>O método “connect_to_endpoint()” será responsável por realizar a conexão à API e extrair os dados. Ele espera receber por parâmetro a url de consulta e a sessão criada pelo HttpHook. Além disso, ele utiliza a biblioteca requests para realizar a requisição e o método “prepare_request()” da sessão para preparar a requisição. A função de log grava a URL que estamos consultando para posterior consulta. Por fim, utilizaremos o método “run_and_check()” herdado da classe HttpHook para executarmos a requisição e retornarmos os dados. Este método espera receber a sessão e a variável de preparação da requisição.</p><p><strong>Percorrendo os resultados paginados</strong></p><pre>def paginate(self, url_raw, session):<br>        lista_json_reponse = [] <br>        response = self.connect_to_endpoint(url_raw,session)<br>        response_json = response.json()<br>        lista_json_reponse.append(response_json)<br>        contador = 1<br><br>        while &quot;next_token&quot; in response_json.get(&quot;meta&quot;, {}) and contador &lt; 100:<br>            next_token = response_json[&#39;meta&#39;][&#39;next_token&#39;]<br>            url = f&#39;{url_raw}&amp;next_token={next_token}&#39;<br><br>            response = self.connect_to_endpoint(url, session)<br>            reponse_json = response.json()<br><br>            lista_json_reponse.append(reponse_json)<br>            contador += 1<br>        return lista_json_reponse</pre><p>O método “paginate()” é o responsável por realizar consultas paginadas na API. Caso o campo “next_token” esteja presente nos dados retornados da consulta anterior, ele será incorporado à URL base e uma nova requisição será executada utilizando o método “connect_to_endpoind()”. A cada requisição o sistema adiciona os dados JSON retornados em uma lista, a qual é retornada no final.</p><p><strong>Obtendo uma sessão http do Airflow</strong></p><pre>def run(self):<br>        session = self.get_conn()<br>        url_raw = self.create_url()<br>        return self.paginate(url_raw,session)</pre><p>Para que a classe TwitterHook funcione é necessário sobrescrever o método “run()” da classe HttpHook. Este método será responsável por pedir uma sessão http ao Airflow utilizando o método “get_conn()” do próprio HttpHook. Além disso, ele agrega todas as funções definidas anteriormente na classe, isto é, a criação da URL base e a consulta paginada.</p><p>Finalmente temos o script completo da classe <strong>TwitterHook</strong>:</p><pre>from airflow.providers.http.hooks.http import HttpHook<br>import requests<br><br>class TwitterHook(HttpHook):<br><br>    def __init__(self, start_time, end_time, query, conn_id=None): <br>        self.start_time = start_time  <br>        self.end_time = end_time      <br>        self.query = query            <br>        self.conn_id = conn_id or &quot;twitter_default&quot;<br><br>        super().__init__(http_conn_id=self.conn_id)<br>    <br>    def create_url(https://medium.com/self):<br>       tweet_fields = &quot;tweet.fields=author_id,conversation_id,created_at,id,in_reply_to_user_id,public_metrics,lang,text&quot;<br>       user_fields = &quot;expansions=author_id&amp;user.fields=id,name,username,created_at&quot;<br>       url_raw = f&quot;{self.base_url}/2/tweets/search/recent?query={self.query}&amp;{tweet_fields}&amp;{user_fields}&amp;start_time={self.start_time}&amp;end_time={self.end_time}&quot;<br>       return url_raw<br>    <br>    def connect_to_endpoint(self, url, session):<br>        request = requests.Request(&#39;get&#39;,url)<br>        prep = session.prepare_request(request)<br>        self.log.info(f&quot;URL: {url}&quot;)<br>        return self.run_and_check(session,prep, {})<br>    <br>    def paginate(self, url_raw, session):<br>        lista_json_reponse = [] <br>        response = self.connect_to_endpoint(url_raw,session)<br>        response_json = response.json()<br>        lista_json_reponse.append(response_json)<br>        contador = 1<br><br>        while &quot;next_token&quot; in response_json.get(&quot;meta&quot;, {}) and contador &lt; 100:<br>            next_token = response_json[&#39;meta&#39;][&#39;next_token&#39;]<br>            url = f&#39;{url_raw}&amp;next_token={next_token}&#39;<br><br>            response = self.connect_to_endpoint(url, session)<br>            reponse_json = response.json()<br><br>            lista_json_reponse.append(reponse_json)<br>            contador += 1<br>        return lista_json_reponse<br>    <br>    def run(self):<br>        session = self.get_conn()<br>        url_raw = self.create_url()<br>        return self.paginate(url_raw,session)</pre><h3>Operator</h3><p>Operadores são classes especiais do Airflow que definem a ação que uma tarefa executará dentro do DAG. O Airflow disponibiliza vários operadores pré-construídos para diferentes tipos de tarefas, como BashOperator e PythonOperator. Todavia, no nosso caso, precisaremos construir nosso próprio Operator.</p><h4>Criando o TwitterOperator</h4><p>Na pasta “<em>airflow_pipeline</em>”, criaremos a pasta “<strong><em>operators</em></strong>” e nela um arquivo denominado “<strong><em>twitter_operator.py”</em></strong>, onde podemos codificar nosso operador.</p><p>Nossa estrutura de pastas ficou assim no VS Code:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/395/1*acM4fVUpxAPdPfVj4QQgdA.png" /></figure><h4>Criando a classe TwitterOperator</h4><p>Dentro do arquivo “twitter_operator.py” definiremos a classe “<strong><em>TwitterOperator</em></strong>” que terá por objetivo específico utilizar o <strong>TwitterHook</strong> para extrair os dados da API e armazená-los em um datalake local.</p><p>Inicialmente nossa classe herdará a classe BaseOperator do airflow. Essa classe contém muitos métodos que são importantes para o comportamento do rastreamento do processo e por executar operações específicas, como scritps, funções e transferências de dados.</p><pre>import sys<br>sys.path.append(&quot;airflow_pipeline&quot;)<br><br>from airflow.models import BaseOperator <br>from hook.twitter_hook import TwitterHook<br>from pathlib import Path<br>import json<br><br>class TwitterOperator(BaseOperator):<br><br>    template_fields = [&quot;file_path&quot;,&quot;start_time&quot;,&quot;end_time&quot;,&quot;query&quot;]<br><br>    def __init__(self, file_path, start_time, end_time, query, **kwargs):<br>        self.start_time = start_time<br>        self.end_time = end_time<br>        self.query = query<br>        self.file_path = file_path <br>        super().__init__(**kwargs)</pre><p>Os campos definidos na variável “<em>template_fields</em>” serão obtidos em tempo de execução todas as vezes em que a DAG for acionada. Esse recurso é chamdado<em> Jinja Templates.</em></p><p>O construtor da classe espera receber os parâmetros “file_path” — que indica o caminho de armazenamento dos dados extraídos; “start_time”, ”end_time” e “query” — que serão usados na montagem da URL de consulta; “self” e **kwargs. Este último é necessário para o correto funcionamento do BaseOperator. Todos esses parâmetros deverão ser passados por quem inicializar o operador e serão repassados ao TwitterHook.</p><p><strong>Criando a estrutura de armazenamento</strong></p><pre>def create_parent_folder(self):<br>        (Path(self.file_path).parent).mkdir(parents=True, exist_ok=True)</pre><p>O método “create_parent_folder()” é o responsável por criar a estrutura de armazenamento conforme o valor da variável “file_path”. Para isso, ela utiliza a função “path()” da biblioteca <em>Pathlib</em> para criar um caminho no sistema operacional.</p><p><strong>Escrevendo os dados extraídos no arquivo</strong></p><pre>def execute(self, context):<br>    self.create_parent_folder()<br><br>    with open(self.file_path, &quot;w&quot;) as output_file:<br>        lista_paginada = TwitterHook(self.start_time,self.end_time,self.query).run()<br>        <br>        for page in lista_paginada:<br>            json.dump(page, output_file, ensure_ascii=False)<br>            output_file.write(&quot;\n&quot;)</pre><p>Para que a classe TwitterOperator funcione é necessário sobrescrever o método “execute()” da classe BaseOperator. Esse método espera receber o parâmetro “<strong><em>context</em></strong>”, que é obtido em tempo de execução do próprio Airflow, embora não seja utilizado no código.</p><p>A primeira ação a ser executada é chamar o método que cria a estrutura de pastas no sistema. Logo em seguida, instanciamos um objeto da classe TwitterOperator para realizar a extração dos tweets em uma lista. Por fim, abrimos o caminho informado na variável “<em>file_path</em>” no modo escrita “w” para armazenar os dados da lista em um único arquivo final.</p><p>Finalmente temos o script completo da classe <strong>TwitterOperator</strong>:</p><pre>import sys<br>sys.path.append(&quot;airflow_pipeline&quot;)<br><br>from airflow.models import BaseOperator <br>from hook.twitter_hook import TwitterHook<br>from pathlib import Path<br>import json<br><br>class TwitterOperator(BaseOperator):<br><br>    template_fields = [&quot;file_path&quot;,&quot;start_time&quot;,&quot;end_time&quot;,&quot;query&quot;]<br><br>    def __init__(self, file_path, start_time, end_time, query, **kwargs):<br>        self.start_time = start_time<br>        self.end_time = end_time<br>        self.query = query<br>        self.file_path = file_path <br>        super().__init__(**kwargs)<br><br>    def create_parent_folder(self):<br>        (Path(self.file_path).parent).mkdir(parents=True, exist_ok=True)<br><br>    def execute(self, context):<br>        self.create_parent_folder()<br>        <br>        with open(self.file_path, &quot;w&quot;) as output_file:<br>          lista_paginada = TwitterHook(self.start_time,self.end_time,self.query).run()<br>           <br>          for page in lista_paginada:<br>              json.dump(page, output_file, ensure_ascii=False)<br>              output_file.write(&quot;\n&quot;)</pre><p>Nosso próximo passo será a construção do DAG para orquestrar as tarefas.</p><h3>DAG</h3><p>Um DAG consiste em uma coleção de tarefas que são executadas de forma ordenada para resolver um grande trabalho. É na DAG que daremos sentido a tudo que foi criado até aqui. Ela funciona como um inicializador e orquestrador das etapas anteriores.</p><p>Na prática, o DAG pode ser considerado o próprio pipeline de dados.</p><h4>Criando o DAG</h4><p>Na pasta “<em>airflow_pipeline</em>”, criaremos a pasta “<strong><em>dags</em></strong>” — esta nomenclatura é importante porque o <em>Airflow</em> deve buscar por ela. Nesta nova pasta, criaremos um arquivo denominado “<strong><em>twitter_dag.py</em></strong>”, no qual construiremos nosso DAG.</p><p>Nossa estrutura de pastas ficou assim no VS Code:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/389/1*3k8XhPIfPa7-HBsdS4WSvg.png" /></figure><p>Iniciaremos o nosso DAG apontando para a pasta onde nossos códigos airflow foram criados, para isso, utilizaremos o <em>import sys</em> e <em>sys.path</em>. Logo em seguida, importaremos a model DAG do Airflow e o operador <em>TwitterOperator</em>.</p><p>Inicialmente chamaremos nossa dag de “<strong><em>TwitterDAG</em></strong>”. Definiremos que o intervalo de extração da nossa dag será diário “<strong><em>@daily</em></strong>” e que desejamos que ela inicie a execução “<strong>start_date</strong>” 6 dias atrás, pensando em uma possível limitação de intervalo de tempo imposta pela API.</p><pre>import sys<br>sys.path.append(“airflow_pipeline”)<br><br>from airflow.models import DAG<br>from operators.twitter_operator import TwitterOperator<br>from os.path import join<br><br>with DAG(dag_id=&quot;TwitterDAG&quot;, start_date=days_ago(6), schedule_interval=&quot;@daily&quot;) as dag:<br><br>...</pre><p><strong>Definindo as variáveis de consulta à API</strong></p><pre>...<br>start_time = &quot;{{data_interval_start.strftime(&#39;%Y-%m-%dT%H:%M:%S.00Z&#39;)}}&quot;<br>end_time = &quot;{{data_interval_end.strftime(&#39;%Y-%m-%dT%H:%M:%S.00Z&#39;)}}&quot;<br>query = &quot;datascience&quot;<br>...</pre><p>As variáveis “<strong><em>start_time</em></strong>” e “<strong><em>end_time</em></strong>” representam o intervalo de busca na API. Elas serão populadas através das variáveis dinâmicas do Airflow “<strong><em>data_interval_start</em></strong>” e “<strong><em>data_interval_end</em></strong>”, sendo formatadas conforme esperado pela API consultada.</p><p>A variável “<strong><em>query</em></strong>” representa a palavra sobre a qual desejamos efetuar a consulta na API. Neste caso, pesquisaremos pela expressão “<strong><em>datascience</em></strong>”, a qual também servirá para dar nome aos diretórios que serão criados.</p><p><strong>Definindo a estrutura do <em>DATA LAKE</em></strong></p><p>Construiremos um <em>data lake</em> para armazenamento dos dados brutos extraídos seguindo o padrão descrito na imagem abaixo.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/667/1*jgWdE_-PtxZjou1aeUVogw.jpeg" /></figure><pre>...<br>    BASE_PATH = str(Path(&quot;~/projetos/projetos_python/proj_twitter_pipeline&quot;).expanduser())<br>    <br>    BASE_FOLDER = join( BASE_PATH, &quot;datalake/twitter_&quot;+query+&quot;/{partition}/{file}&quot;)<br>    <br>    PARTITION = &quot;extract_date={{ data_interval_start.strftime(&#39;%Y-%m-%d&#39;) }}&quot;<br>    FILE = query + &quot;_{{ ds_nodash }}.json&quot;<br>   <br>    file_path = BASE_FOLDER.format(partition=PARTITION,file=FILE)<br>...</pre><p>A variável BASE_PATH representa o caminho base do nosso projeto, onde criaremos o <em>data lake</em>. BASE_FOLDER cria a estrutura do <em>data lake</em>, onde {partition} e {file} serão substituídos pelas variáveis PARTITION e FILE, respectivamente. A variável “file_path” agrega todas as variáveis anteriores, representando o caminho completo até o arquivo que será salvo no formato json.</p><p><strong>Realizando a consulta com o TwitterOperator</strong></p><pre>... <br>twitter_extract = TwitterOperator(file_path=file_path,start_time=start_time,end_time=end_time,query=query,task_id=&quot;twitter_extract_&quot;+query) <br>...</pre><p>A variável “twitter_extract” recebe um objeto da classe “TwitterOperator” que é a responsável por realizar a extração e armazenamento dos dados extraídos da API. Para isso, passaremos as variáveis definidas anteriormente para o construtor do TwitterOperator: “file_path” — para indicar o local do armazenamento; “start_time”,“end_time” e “query” — para montar a url de consulta e a variável “task_id” — que é o nome da tarefa a qual o operador se vincula e que aparecerá na interface web do airflow.</p><p>Finalmente temos o script completo do nosso DAG:</p><pre>import sys<br>sys.path.append(&quot;airflow_pipeline&quot;)<br><br>from airflow.models import DAG <br>from operators.twitter_operator import TwitterOperator<br>from os.path import join<br><br>with DAG(dag_id=&quot;TwitterDAG&quot;, start_date=days_ago(6), schedule_interval=&quot;@daily&quot;) as dag:<br>     # definindo os parâmetros da url de consulta<br>     start_time = &quot;{{data_interval_start.strftime(&#39;%Y-%m-%dT%H:%M:%S.00Z&#39;)}}&quot;<br>     end_time = &quot;{{data_interval_end.strftime(&#39;%Y-%m-%dT%H:%M:%S.00Z&#39;)}}&quot;<br>     query = &quot;datascience&quot;<br><br>     # definindo a estrutura de armazenamento do datalake<br>     BASE_PATH = str(Path(&quot;~/projetos/projetos_python/proj_twitter_pipeline&quot;).expanduser())<br>     BASE_FOLDER = join( BASE_PATH, &quot;datalake/twitter_&quot;+query+&quot;/{partition}/{file}&quot;)<br>     PARTITION = &quot;extract_date={{ data_interval_start.strftime(&#39;%Y-%m-%d&#39;) }}&quot;<br>     FILE = query + &quot;_{{ ds_nodash }}.json&quot;<br>   <br>     file_path = BASE_FOLDER.format(partition=PARTITION,file=FILE)<br><br>     # realizando extracao e armazenamento<br>     twitter_extract = TwitterOperator(file_path=file_path,start_time=start_time,end_time=end_time,query=query,task_id=&quot;twitter_extract_&quot;+query)</pre><h3>Executando o DAG</h3><p>Tendo finalizado e salvo os arquivos, inicializaremos o servidor web via terminal. Lembre-se de ter exportado a variável de ambiente AIRFLOW_HOME e de estar com o ambiente virtual ativado.</p><pre>airflow standalone</pre><p>Na interface web deve aparecer o nosso DAG “<strong>TwitterDAG</strong>”:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/274/1*Wl6zmxh8dXy9F1akSIIxEA.png" /></figure><p>Ao abri-lo, temos acesso a algumas informações, como a data de execução, por exemplo. Para testá-lo, clique no símbolo de “Pause/Unpause DAG” no canto superior esquerdo e na opção “Auto-refresh” no canto superior direito. Feito isso, o DAG aparecerá como ativo, no canto superior esquerdo.</p><p>Como nossa DAG foi programada para extrair dados de 6 dias atrás a contar da data de agendamento, em poucos segundos veremos as 6 instâncias do DAG run ficarem na cor verde escuro indicando que a execução foi bem-sucedida.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/420/1*HAiS7-vL1b2WiDRlEpksfA.png" /></figure><p>Por fim, para nos certificar que a extração e o armazenamento dos dados funcionaram corretamente, acessaremos a estrutura de pastas do nosso projeto no VS Code. Podemos ver que a estrutura de armazenamento do <em>data lake</em> foi criada conforme esperado e nela constam os arquivos json com os dados extraídos.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/245/1*x_Zx-oDXqw9M-hTTUZ1kOg.png" /></figure><p>Alcançamos nosso objetivo!</p><h3>Resumo:</h3><p>Neste artigo aprendemos a trabalhar com conexões, hook, operator e DAG. Além disso, criamos um <em>data lake</em> para armazenamento dos tweets extraídos da API consultada. Dessa forma os dados extraídos estarão disponíveis para serem analizados por pessoas cientistas de dados.</p><h4>GitHub:</h4><p><a href="https://github.com/sanchesmil/Airflow-Extract-Transform-Tweets">https://github.com/sanchesmil/Airflow-Extract-Transform-Tweets</a></p><h4>Referência:</h4><p>Curso <a href="https://cursos.alura.com.br/course/apache-airflow-extracao-dados">Apache Airflow: extração de dados (Alura)</a></p><p>Instrutores: <a href="https://cursos.alura.com.br/user/igor-nascimento-flipe">Igor Nascimento</a> e <a href="https://cursos.alura.com.br/user/danpsiqueira">Daniel Siqueira</a></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=dbd72d0c4ad9" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Pipeline de dados meteorológicos no Airflow]]></title>
            <link>https://medium.com/@sanchesmil/orquestrando-pipeline-no-airflow-para-extra%C3%A7%C3%A3o-de-dados-meteorol%C3%B3gicos-6c720e35c55d?source=rss-f0415d58824b------2</link>
            <guid isPermaLink="false">https://medium.com/p/6c720e35c55d</guid>
            <category><![CDATA[data-pipeline]]></category>
            <category><![CDATA[airflow]]></category>
            <dc:creator><![CDATA[Pedro Sanches]]></dc:creator>
            <pubDate>Fri, 15 Dec 2023 15:06:50 GMT</pubDate>
            <atom:updated>2023-12-26T16:18:07.612Z</atom:updated>
            <content:encoded><![CDATA[<h3>Visão geral</h3><p>Neste artigo faremos a orquestração de um datapipeline com a ferramenta AIRFLOW para extração, transformação e armazenamento de dados meteorológicos semanais na cidade de Boston, EUA. O pipeline será configurado para executar todas as segundas-feiras e armazenará a previsão para os próximos 7 dias. Estas informações serão úteis para que uma empresa de turismos consiga organizar passeios conforme a previsão do tempo. Para isso, a cada execução do pipeline no Airflow faremos uma requisição na api TIMELINE WEATHER API que nos fornecerá os dados meteorológicos. Como resultado final, a cada execução criaremos uma pasta contendo os dados brutos, os dados de temperatura e as condições climáticas separados em arquivos csv.</p><h4>O que vamos aprender?</h4><ul><li>Executar o Airflow localmente</li><li>Navegar pela interface do Airflow</li><li>Desenvolver um DAG que extrai dados da previsão do tempo</li><li>Criar tarefas com os operadores BashOperator e PythonOperator</li><li>Utilizar o Jinja Templates</li><li>Utilizar uma API com dados climáticos</li><li>Extrair dados da previsão do tempo</li><li>Salvar os dados extraídos em arquivos csv</li></ul><h4>Tecnologias utilizadas</h4><ul><li>Sistema Operacional Ubuntu</li><li>Editor VS Code</li><li>Ferramenta Apache Airflow</li><li>Linguagem Python e suas libs (requests, pandas e pendulum)</li><li>API de informações meteorológicas: TIMELINE WEATHER API</li></ul><h4>Pré-requisitos</h4><ul><li>Linguagem Python</li><li>Estruturas de dados: listas e dicionários</li><li>Conhecimento básico em Airflow</li><li>Comandos Linux</li><li>Editor VS Code</li></ul><h4>Preparando o ambiente: Python3.9, ambiente virtual e Airflow</h4><p>Para a execução deste projeto, utilizei o Python3.9, ambiente virtual e Airflow 2.3.2. Caso você não tenha alguma dessas ferramentas instaladas, sugiro ler o seguinte artigo:</p><p><a href="https://medium.com/@sanchesmil/instalando-o-apache-airflow-no-ubuntu-3eba864882c3">https://medium.com/@sanchesmil/instalando-o-apache-airflow-no-ubuntu-3eba864882c3</a></p><h4>Criando a pasta do projeto</h4><p>Considerando que estejamos com o terminal aberto, criaremos uma nova pasta chamada “<em>proj_dados_climaticos</em>” e acessaremos ela, conforme os comandos abaixo.</p><pre>mkdir proj_dados_climaticos</pre><pre>cd proj_dados_climaticos</pre><h4>Criando e ativando o ambiente virtual na pasta do projeto:</h4><p>Dentro de “proj_dados_climaticos”, criaremos o ambiente virtual no qual instalaremos o <em>Airflow</em>. Como queremos utilizar o Python 3.9, nosso comando ficará assim:</p><ul><li><strong>Criando o ambiente virtual:</strong></li></ul><pre>python3.9 -m venv venv</pre><ul><li><strong>Ativando o ambiente virtual:</strong></li></ul><pre>source venv/bin/activate</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/664/1*b_Cij1t38aYt1pBfSxoZOQ.png" /></figure><h4>Instalando o AIRFLOW</h4><p>Estando na raiz do projeto, após ativar o ambiente virtual, faremos a instalação do Airflow. Para realizar a instalação do Airflow utilizaremos o gerenciador de pacotes <em>pip</em>, do Python, e passaremos a versão desejada, 2.3.2. Em seguida, passaremos a URL do arquivo de restrição, que especifica as versões das bibliotecas que o Airflow irá trabalhar, no nosso caso, a versão do <em>Airflow</em> que estamos instalando (2.3.2) e a versão do Python que estamos utilizando (3.9).</p><pre>pip install &#39;apache-airflow==2.3.2&#39; --constraint  &quot;https://raw.githubusercontent.com/apac</pre><h4>Abrindo o projeto no VSCode</h4><p>Estando na raiz de “proj_dados_climaticos”, abra o projeto no VS Code executando o comando abaixo.</p><pre>code .</pre><ul><li><strong>Estrutura de pastas no VS Code até aqui</strong></li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/252/1*ERxn5OFupIuE5A6r4AC6Rw.png" /></figure><h4>Criando e configurando um DAG</h4><p>Para iniciar, criaremos uma pasta chamada “dags”. Nela criaremos um script chamado “<em>dados_climaticos_dag.py</em>”.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/259/1*aoqji0G19FAtPc9J9ymCSQ.png" /></figure><p>No arquivo “<em>dados_climaticos_dag.py</em>” desenvolveremos o seguinte código:</p><ul><li><strong>Importação das bibliotecas e pacotes:</strong></li></ul><pre>from airflow import DAG <br>from airflow.operators.bash_operator import BashOperator<br>from airflow.operators.python_operator import PythonOperator<br>from airflow.macros import ds_add<br>import pendulum<br>from os.path import join<br>import pandas as pd</pre><ul><li><strong>Definição do DAG:</strong></li></ul><pre>with DAG(<br>    &quot;dados_climaticos&quot;,<br>    start_date=pendulum.datetime(2023,11,27, tz=&quot;UTC&quot;),<br>    schedule_interval=&#39;0 0 * * 1&#39;,<br>) as dag:</pre><p>Nomeamos o dag como “<em>dados_climaticos</em>” e definimos a data de início <em>start_date</em> como 27/11/2023, que corresponde à última segunda-feira anterior ao mês atual (dez/23 na data de publicação deste post). Além disso, utilizamos uma <em>cron expression</em> para definir o intervalor de agendamento de execução da dag, que neste caso, irá rodar toda segunda-feira.</p><ul><li><strong>Criando as Tarefas</strong></li></ul><p>A primeira tarefa deve realizar a criação de uma pasta no caminho indicado, a qual armazenará os dados da previsão do tempo. Para isso, utilizaremos o <em>BashOperator(). Além disso, n</em>omearemos a pasta seguindo o padrão “<em>semana=ano-mes-dia</em>” (ex.: semana=2023–11–04), isso facilitará a identificação e a organização dos dados pela empresa de turismo. Para isso, utilizaremos a variável dinâmica “<em>data_interval_end” </em>fornecida pelo Airflow em tempo de execução, ela informa a data de acionamento do DAG.</p><pre>tarefa_1 = BashOperator(<br>        task_id = &#39;cria_pasta&#39;,<br>        bash_command= &#39;mkdir -p &quot;~/projetos/projetos_python/proj_dados_climaticos/semana={{data_interval_end.strftime(&quot;%Y-%m-%d&quot;)}}&quot;&#39;<br>)</pre><p>A segunda tarefa deve extrair os dados da API de dados climáticos e armazená-los na pasta criada pela tarefa_1. Nela, chamaremos o <em>PythonOperator(),</em> que receberá os argumentos <em>task_id, </em>nomeado como <em>‘extrai_dados_api&#39;</em>; <em>python_callable</em>, que recebe o nome da função ou o código que deve ser executado por este operador; e <em>op_kwargs, </em>que recebe um dicionário de argumentos que serão descompactados na função definida em <em>python_callable.</em></p><pre>tarefa_2 = PythonOperator(<br>        task_id = &#39;extrai_dados_api&#39;,<br>        python_callable= extrair_dados,<br>        op_kwargs= {&#39;data_interval_end&#39;: &#39;{{data_interval_end.strftime(&quot;%Y-%m-%d&quot;)}}&#39;}<br>)</pre><ul><li><strong>Definindo a função de extração e armazenamento</strong></li></ul><p>O conteúdo dessa função será, basicamente, o código do pipeline de dados onde faremos a extração e armazenamento dos dados da previsão do tempo. Ela espera receber como argumento a <em>data_interval_end, </em>isto é<em>, </em>a data exata de quando o nosso DAG é acionado. Além disso, precisamos definir a cidade de consulta e a chave de acesso à API, as quais serão usadas para formação da url de consulta. Na url, para definirmos a data final do intervalo de dados a serem buscados, usaremos a macro <em>ds_add()</em>, ela permite a adição de uma quantidade de dias a uma data informada. No nosso caso, somaremos 7 dias ao <em>data_interval_end</em>. Atente para o fato de que o caminho para armazenar os arquivos extraídos deve ser o mesmo indicado na tarefa_1 de criação da pasta.</p><pre>def extrair_dados(data_interval_end):<br>        city = &#39;Boston&#39; # cidade de consulta<br>        key = &#39;EEVFX48UQV4P92ERLDHM6NYYY&#39; # chave de acesso à API &#39;visualcrossing&#39;<br><br>        # monta a url de consulta a api<br>        url = join(&#39;https://weather.visualcrossing.com/VisualCrossingWebServices/rest/services/timeline/&#39;,<br>                f&#39;{city}/{data_interval_end}/{ds_add(data_interval_end,7)}?unitGroup=metric&amp;include=days&amp;key={key}&amp;contentType=csv&#39;) <br><br>        # se necessário<br>        proxies = {<br>            &#39;http&#39;: &#39;http://xx.xxx.xxx.xxx:8080&#39;,<br>            &#39;https&#39;: &#39;http://xx.xxx.xxx.xxx:8080&#39;<br>        }<br><br>        # executa a requisicao do tipo get usando a lib requests<br>        dados = requests.get(url,proxies=proxies).text<br><br>        # formata os dados retornados usando a lib IO<br>        dados = pd.read_csv(io.StringIO(dados))<br><br>        # define o caminho para salvar os arquivos criando um novo diretório para cada semana de consulta<br>        file_path = f&#39;~/projetos/projetos_python/proj_dados_climaticos/semana={data_interval_end}/&#39;<br><br>        # armazena todos os dados brutos obtidos da api no caminho indicado usando a lib pandas<br>        dados.to_csv(file_path + &#39;dados_brutos.csv&#39;)<br><br>        # armazena somente info de temperatura (data,mínima,temp,máxima)<br>        dados[[&#39;datetime&#39;,&#39;tempmin&#39;,&#39;temp&#39;,&#39;tempmax&#39;]].to_csv(file_path + &#39;temperaturas.csv&#39;)<br><br>        # armazena somente info de condições climáticas (data, descricao (ensolarado, nublado, etc) e ícone) dos dados obtidos<br>        dados[[&#39;datetime&#39;,&#39;description&#39;,&#39;icon&#39;]].to_csv(file_path + &#39;condicoes.csv&#39;)</pre><ul><li><strong>Definindo a ordem de execução das tarefas</strong></li></ul><p>A <em>tarefa_1 </em>deve ser executada primeiro, já que é responsável por criar as pastas onde os dados extraídos pela <em>tarefa_2</em> serão armazenados.</p><pre>tarefa_1 &gt;&gt; tarefa_2</pre><ul><li><strong>Configuração final do nosso código</strong></li></ul><p>Finalmente temos o script completo de criação do nosso DAG no arquivo <em>dados_climaticos_dap.py:</em></p><pre>from airflow.models import DAG <br>from airflow.operators.bash import BashOperator<br>from airflow.operators.python import PythonOperator<br>from airflow.macros import ds_add<br>from os.path import join <br>import pendulum<br>import pandas as pd   <br>import io<br>import requests<br><br>with DAG(<br>    &#39;dados_climaticos&#39;,<br>    start_date= pendulum.datetime(2023,11,27, tz=&#39;UTC&#39;),<br>    schedule_interval=&#39;0 0 * * 1&#39;, <br>) as dag:<br>    <br>    tarefa_1 = BashOperator(<br>        task_id = &#39;cria_pasta&#39;,<br>        bash_command= &#39;mkdir -p &quot;~/projetos/projetos_python/proj_dados_climaticos/semana={{data_interval_end.strftime(&quot;%Y-%m-%d&quot;)}}&quot;&#39;<br>    )<br><br>    def extrair_dados(data_interval_end):<br>        city = &#39;Boston&#39;<br>        key = &#39;EEVFX48UQV4P92ERLDHM6NYYY&#39;<br><br>        url = join(&#39;https://weather.visualcrossing.com/VisualCrossingWebServices/rest/services/timeline/&#39;,<br>                f&#39;{city}/{data_interval_end}/{ds_add(data_interval_end,7)}?unitGroup=metric&amp;include=days&amp;key={key}&amp;contentType=csv&#39;) <br><br>        proxies = {<br>            &#39;http&#39;: &#39;http://10.228.108.100:8080&#39;,<br>            &#39;https&#39;: &#39;http://10.228.108.100:8080&#39;<br>        }<br><br>        dados = requests.get(url,proxies=proxies).text<br>        dados = pd.read_csv(io.StringIO(dados))<br><br>        file_path = f&#39;~/projetos/projetos_python/proj_dados_climaticos/semana={data_interval_end}/&#39;<br><br>        dados.to_csv(file_path + &#39;dados_brutos.csv&#39;)<br>        dados[[&#39;datetime&#39;,&#39;tempmin&#39;,&#39;temp&#39;,&#39;tempmax&#39;]].to_csv(file_path + &#39;temperaturas.csv&#39;)<br>        dados[[&#39;datetime&#39;,&#39;description&#39;,&#39;icon&#39;]].to_csv(file_path + &#39;condicoes.csv&#39;)<br><br>    tarefa_2 = PythonOperator(<br>        task_id = &#39;extrai_dados_api&#39;,<br>        python_callable= extrair_dados,<br>        op_kwargs= {&#39;data_interval_end&#39;: &#39;{{data_interval_end.strftime(&quot;%Y-%m-%d&quot;)}}&#39;}<br>    )<br><br>    tarefa_1 &gt;&gt; tarefa_2</pre><p>Nosso DAG está pronto! O próximo passo será subir o Airflow e executar o DAG.</p><h4>Subindo o AIRFLOW</h4><ul><li><strong>Exportando a variável de ambiente </strong><strong>AIRFLOW_HOME:</strong></li></ul><pre>export AIRFLOW_HOME=~/projetos/projetos_python/proj_dados_climaticos</pre><p>Obs.1: Devemos exportar a variável de ambiente apontando para o diretório raiz do nosso projeto onde instalamos o <em>Airflow</em>.</p><ul><li><strong>Executando o Airflow:</strong></li></ul><pre>airflow standalone</pre><p>Este comando é responsável por iniciar o banco de dados padrão do <em>Airflow</em>, criar um novo usuário e senha para que possamos acessá-lo, e executar os dois principais serviços do <em>Airflow</em>: o <em>scheduler</em> e o <em>web services</em>.</p><ul><li><strong>Acessando a interface Web do Airflow:</strong></li></ul><p>No navegador, acessaremos “localhost:8080” e logaremos com o usuário e senha fornecidos pelo Airflow. Na página home veremos o dag “dados_climaticos”.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/812/1*5ZQihLCr_rv98GvmvstjRQ.png" /></figure><h4>Executando o DAG</h4><p>Após acessar nosso dag, ativaremos o botão de &quot;Pause/Unpause DAG&quot; e clicaremos em &quot;Auto-refresh&quot; para executá-lo.</p><p>Perceba que começarão a surgir alguns DAGs runs representando a execução do nosso DAG, assim como as tasks em instâncias. Note que aparecem todas na cor verde escuro, indicando que foram executadas com sucesso.</p><p>Temos mais de um DAG run porque também estamos extraindo dados climáticos de algumas semanas atrás, mas o último representa justamente a execução do DAG na segunda-feira da semana atual.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/440/1*O4FkoY2SBrDKEt-sZFItsQ.png" /></figure><ul><li><strong>Consultando a pasta de armazenamento</strong></li></ul><p>Para conferir o funcionamento do DAG, voltemos ao <em>VS Code</em>. Na raiz do projeto deve aparecer as pastas nomeadas de acordo com a semana as quais correspondem. Dentro destas pastas deve aparecer os arquivos de condições, dados brutos e temperaturas no formato csv.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/261/1*2YJ9kX24tZd1Jp-1sduJ_A.png" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/841/1*03sntd0BM914vWr0awgi8A.png" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/787/1*qB4RQzp72nz1PBBOXrHOGA.png" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/382/1*nftqAL7E7j9kFd616TevPQ.png" /></figure><p>Pronto! Conseguimos desenvolver um DAG que possui duas tarefas: a primeira é responsável por criar pastas nomeadas com a data do início da semana de execução, onde os arquivos serão armazenados; a segunda é responsável por extrair os dados da previsão do tempo da semana e armazená-los nas respectivas pastas. Dessa forma, a empresa de turismo conseguirá acessar estes dados para organizar os passeios de acordo com as condições climáticas. Além do mais, nosso DAG é automatizado, ou seja, agendado para rodar à 00h de toda segunda-feira.</p><h3>Assim, finalizamos nosso projeto!</h3><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=6c720e35c55d" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Instalando o Apache AIRFLOW no Ubuntu]]></title>
            <link>https://medium.com/@sanchesmil/instalando-o-apache-airflow-no-ubuntu-3eba864882c3?source=rss-f0415d58824b------2</link>
            <guid isPermaLink="false">https://medium.com/p/3eba864882c3</guid>
            <category><![CDATA[airflow-installation]]></category>
            <dc:creator><![CDATA[Pedro Sanches]]></dc:creator>
            <pubDate>Thu, 14 Dec 2023 13:46:57 GMT</pubDate>
            <atom:updated>2023-12-14T14:05:04.634Z</atom:updated>
            <content:encoded><![CDATA[<h3>Visão geral</h3><p>Neste artigo realizaremos a instalação do Apache Airflow em um ambiente linux (Ubuntu 20.04.6). Para isso, será necessário realizar a configuração do ambiente, incluindo a instalação do Python 3.9 e os ambientes virtuais dessa versão.</p><h4>1 Preparando o ambiente: Python 3.9 e ambiente virtual</h4><p>Considerando que estejamos no sistema operacional Ubuntu para desenvolver o projeto, nós vamos utilizar a linguagem Python na sua versão 3.9 e também vamos criar um ambiente virtual. Para isso, acessaremos o terminal e digitaremos os comandos na sequência abaixo.</p><ul><li><strong>Atualizando os pacotes do Ubuntu:</strong></li></ul><pre>sudo apt update<br>sudo apt upgrade</pre><ul><li><strong>Ativando o repositório no Ubuntu que permite a instalação de diferentes versões do Python:</strong></li></ul><pre>sudo add-apt-repository ppa:deadsnakes/ppa</pre><ul><li><strong>Instalando o Python 3.9:</strong></li></ul><pre>sudo apt install python3.9</pre><ul><li><strong>Conferindo a instalação:</strong></li></ul><pre>python3.9 --version</pre><ul><li><strong>Instalando o pacote de ambientes virtuais da versão Python3.9:</strong></li></ul><pre>sudo apt install python3.9-venv</pre><p>Um ambiente virtual Python é como uma caixa separada onde você pode instalar e gerenciar pacotes Python para um projeto específico, sem interferir em outros projetos ou no Python do sistema.</p><p>Finalizamos as instalações necessárias. Agora, criaremos a pasta do projeto na qual realizaremos a instalação e configuração do <em>Airflow</em>.</p><h4>2 Criando a pasta do projeto:</h4><p>Considerando que estejamos com o terminal aberto, acessaremos a pasta <em>Documents </em>e criaremos uma nova pasta chamada “<em>projeto_airflow</em>”, conforme os comandos abaixo.</p><pre>cd Documents</pre><pre>mkdir projeto_airflow</pre><pre>cd projeto_airflow</pre><h4>3 Criando e ativando o ambiente virtual na pasta do projeto:</h4><p>Dentro de “<em>projeto_airflow</em>”, criaremos o ambiente virtual no qual instalaremos o <em>Airflow</em>. Como queremos utilizar o Python 3.9, nosso comando ficará assim:</p><ul><li><strong>Criando o ambiente virtual:</strong></li></ul><pre>python3.9 -m venv venv</pre><ul><li><strong>Ativando o ambiente:</strong></li></ul><pre>source venv/bin/activate</pre><h4>4 Instalando o AIRFLOW</h4><p>Para realizar a instalação do Airflow utilizaremos o gerenciador de pacotes <em>pip</em>, do Python, e passaremos a versão desejada, 2.3.2. Em seguida, passaremos a URL do arquivo de restrição, que especifica as versões das bibliotecas que o Airflow irá trabalhar, no nosso caso, a versão do <em>Airflow</em> que estamos instalando (2.3.2) e a versão do Python que estamos utilizando (3.9).</p><pre>pip install &#39;apache-airflow==2.3.2&#39; --constraint  &quot;https://raw.githubusercontent.com/apache/airflow/constraints-2.3.2/constraints-3.9.txt&quot;</pre><h4>5 Executando o AIRFLOW</h4><ul><li><strong>Exportando a variável de ambiente </strong><strong>AIRFLOW_HOME:</strong></li></ul><pre>export AIRFLOW_HOME=~/Documents/projeto_airflow</pre><p>Obs.1: Devemos exportar a variável de ambiente apontando para o diretório no qual instalamos o <em>Airflow</em>.</p><p>Obs.2: É necessário exportá-la sempre que formos executar o <em>Airflow</em>.</p><ul><li><strong>Executando o Airflow:</strong></li></ul><pre>airflow standalone</pre><p>Este comando é responsável por iniciar o banco de dados padrão do <em>Airflow</em>, criar um novo usuário e senha para que possamos acessá-lo, e executar os dois principais serviços do <em>Airflow</em>: o <em>scheduler</em> e o <em>web services</em>.</p><p>Podemos observar, no log de execução, que há um trecho indicando que o <em>Airflow</em> está pronto (“Airflow is ready”) seguido de um usuário (“admin”) e uma senha, que consta em “password”.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/486/1*U6PDKgTGHml91lEKV_NX9g.png" /></figure><ul><li><strong>Acessando a interface Web do Airflow:</strong></li></ul><p>No navegador, acessaremos “localhost:8080”, e logaremos com o usuário e senha que nos foram fornecidos para acessar a interface do <em>Airflow</em>.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/491/1*0BMjRgxGdcwbgLMaUXRe3w.png" /></figure><p>Logo em seguida, somos redirecionados para a página home do Airflow.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/635/1*j0B8MZHfpf8LXupxH0GSIQ.png" /></figure><h3>Assim, finalizamos nosso projeto de instalação do Airflow no Ubuntu!</h3><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=3eba864882c3" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Pipeline ETL na API do GitHub utilizando a biblioteca Requests do Python]]></title>
            <link>https://medium.com/@sanchesmil/pipeline-etl-utilizando-a-biblioteca-requests-do-python-6100dec91ab4?source=rss-f0415d58824b------2</link>
            <guid isPermaLink="false">https://medium.com/p/6100dec91ab4</guid>
            <category><![CDATA[pipeline]]></category>
            <category><![CDATA[etl]]></category>
            <category><![CDATA[requests-library]]></category>
            <category><![CDATA[python]]></category>
            <category><![CDATA[data-engineering]]></category>
            <dc:creator><![CDATA[Pedro Sanches]]></dc:creator>
            <pubDate>Mon, 16 Oct 2023 12:36:28 GMT</pubDate>
            <atom:updated>2023-10-16T20:01:49.988Z</atom:updated>
            <content:encoded><![CDATA[<h3><strong>Repositório</strong></h3><p><a href="https://github.com/sanchesmil/linguagens-repositorios-empresas">GitHub - sanchesmil/linguagens-repositorios-empresas: Linguagens de programação utilizadas por grandes empresas em seus repositórios</a></p><h3>Tecnologias utilizadas</h3><ul><li>Linguagem Python (OO)</li><li>Biblioteca Requests (Python)</li><li>Biblioteca Pandas (Python)</li><li>Biblioteca base64 (Python)</li><li>API do GitHub</li></ul><h3>Visão geral</h3><p>Neste artigo criaremos um pipeline ETL para extração de dados da API do GitHub utilizando a biblioteca Requests do Python e o paradigma de orientação a objetos. O objetivo do projeto é obter dados sobre as linguagens de programação utilizadas por grandes empresas, como Amazon, Spotify, Netflix e Apple. Para isso, acessaremos os repositórios públicos de cada empresa hospedados no GitHub e extrairemos as informações necessárias ao nosso objetivo. Como resultado final, para cada empresa analisada, criaremos um arquivo csv contendo o nome dos repositórios públicos e suas respectivas linguagens.</p><h3>O que vamos aprender?</h3><ul><li>Requisições GET, POST, PUT e DELETE utilizando a biblioteca requests</li><li>Extrair e transformar dados no formato JSON</li><li>Trabalhar com diferentes <em>endpoints</em></li><li>Entender os status_codes</li><li>Fazer a autenticação e paginação na API do GitHub</li><li>Estruturar o pipeline em classes e métodos</li></ul><h3>Pré-requisitos</h3><ul><li>Linguagem Python</li><li>Estruturas de dados: listas e dicionários</li><li>Conceitos de orientação a objeto com Python</li><li>Comandos Linux</li><li>Editor Visual Studio Code</li></ul><h3><strong>Preparando o ambiente: Python e ambiente virtual</strong></h3><p>Considerando que estejamos em um ambiente Linux para desenvolver o projeto, nós vamos utilizar a linguagem Python e também vamos criar um ambiente virtual.</p><p>Um ambiente virtual Python é como uma caixa separada onde você pode instalar e gerenciar pacotes Python para um projeto específico, sem interferir em outros projetos ou no Python do sistema.</p><p>Para a criação do ambiente virtual é necessário que os pacotes PIP e VENV estejam instalados no sistema.</p><p>Antes de partirmos para a criação do nosso ambiente virtual, vamos criar uma pasta para o nosso projeto. Para isso, podemos abrir o terminal e utilizar o comando mkdir:</p><pre>mkdir projeto_requests</pre><p>Acesse a pasta:</p><pre>cd projeto_requests</pre><p>Feito isso, podemos executar o comando para criação do ambiente virtual:</p><pre>python3 -m venv venv</pre><p>Em seguida, podemos ativar o ambiente:</p><pre>source venv/bin/activate</pre><p>E com o ambiente ativado, podemos instalar as bibliotecas que vamos utilizar no decorrer do nosso projeto, quais sejam, ‘requests’ e ‘pandas’:</p><pre>pip install requests==2.28.2</pre><pre>pip install pandas==2.0.0</pre><h3>Utilizando o VSCode</h3><p>O <strong>VSCode</strong> será nossa ferramenta principal para escrever o código do projeto. Com o VS Code instalado, precisaremos acessar a pasta do projeto no terminal e executar o seguinte comando para abrir o VS Code:</p><pre>cd projeto_requests</pre><pre>code .</pre><p>Obs.: Para trabalharmos da melhor forma com Python no VS Code é importante que a extensão “Python” esteja instalada.</p><h3>Criando as classes do projeto</h3><p>Neste projeto, criaremos duas classes. A primeira classe, chamada <em>“DadosRepositorios”</em>, será responsável pela extração e transformação dos dados, convertendo-os em um arquivo CSV formatado. A segunda classe, chamada <em>“ManipulaRepositorios”</em>, será responsável por criar um repositório publico no GitHub e subir os arquivos CSV gerados na etapa anterior.</p><p>Inicialmente criaremos o arquivo dados_repos.py e faremos a importação das bibliotecas que utilizaremos na extração e transformação dos dados.</p><pre>import requests<br>import pandas as pd<br><br>from math import ceil</pre><p>Logo em seguida, declaramos a classe DadosRepositorio e seus atributos no método construtor.</p><p>A assinatura do construtor possuirá o parâmetro owner que representa o nome do dono da conta do GitHub de onde extrairemos os dados.</p><p>O atributo api_base_url representa a URL base da API do GitHub. O access_token consiste em uma string de autenticação fornecida pelo GitHub. Atenção: Você deve substituir pelo seu token. Por último temos o atributo headers em que montamos o dicionário com o token de autenticação e a versão do API do GitHub que utilizaremos para realizar as requisições.</p><pre>class DadosRepositorios:<br><br>    def __init__(self, owner):<br>        self.owner = owner<br>        self.api_base_url = &#39;https://api.github.com&#39;<br>        self.access_token = &#39;seu_token&#39;<br>        self.headers = {&#39;Authorization&#39;: &#39;Bearer &#39; + self.access_token,<br>                        &#39;X-GitHub-Api-Version&#39;: &#39;2022-11-28&#39;}</pre><p>Nessa classe teremos um total de cinco métodos. O primeiro deles é o conta_repositorios. Nesse método, obteremos o numero de repositórios públicos de uma conta no GitHub.</p><pre>def conta_repositorios(self,owner):<br>    # monta o endpoint de consulta<br>    url = f&#39;{self.api_base_url}/users/{owner}&#39;<br>    <br>    # requisicao GET usando a lib requests<br>    response = requests.get(url,headers=self.headers)<br><br>    # obtem a qtd total de repositorios publicos <br>    total_repos = response.json()[&#39;public_repos&#39;]<br><br>    return total_repos</pre><p>No segundo método lista_repositorios realizamos a paginação dos repositórios e a extração das informações de cada repositório em uma lista.</p><pre>def lista_repositorios(self):<br>    # define uma lista de repositorios<br>    repos_list = []<br><br>    # obtem o numero total de repositorios de uma conta no GitHub<br>    total_repos = self.conta_repositorios(self.owner)<br><br>    # divide os repositorios em páginas conforme o GitHub<br>    pages = ceil(total_repos / 30)<br>	<br>    # paginação: percorre todos os repositorios contidos em cada página<br>    for page_num in range(1, pages):<br>        try:<br>            # monta o endpoint de consulta <br>            url = f&#39;{self.api_base_url}/users/{self.owner}/repos?page={page_num}&#39;<br>            <br>            # realiza uma requisicao GET usando a lib requests<br>            response = requests.get(url, headers=self.headers)<br>            <br>            # armazena os dados do repositório na lista<br>            repos_list.append(response.json())<br>        except:<br>            repos_list.append(None)<br><br>    return repos_list</pre><p>Nos próximos dois métodos aplicamos as transformações necessárias para obter o nome do repositório e a linguagem de programação utilizada no seu desenvolvimento.</p><pre><br>def nomes_repositorios(self, repos_list):<br>    # define uma lista que armazenará o nome dos repositorios<br>    repos_names = []<br><br>    for page in repos_list:<br>        for repo in page:<br>            try:<br>                repos_names.append(repo[&#39;name&#39;])<br>            except:<br>                pass<br>    return repos_names</pre><pre>def linguagens_repositorios(self,repos_list):<br>    # define uma lista que armazenará a linguagem de cada repositorio<br>    repos_lang = []<br><br>    for page in repos_list:<br>        for repo in page:<br>            try:<br>                repos_lang.append(repo[&#39;language&#39;])<br>            except:<br>                pass<br>    return repos_lang</pre><p>Por fim, temos o método cria_dataframe_linguagens. A partir dele faremos a criação de um <em>dataframe</em> com as colunas “<em>repositorio”</em> e “<em>linguagem” </em>utilizando a biblioteca pandas.</p><p>Nesse método chamamos os métodos anteriores <em>lista_repositorios(), nomes_repositorios() e linguagens_repositorios().</em></p><pre>def cria_dataframe_linguagens(self):<br>  repositorios = self.lista_repositorios()<br>  repositorios_nomes = self.nomes_repositorios(repositorios)<br>  repositorios_linguagens = self.linguagens_repositorios(repositorios)<br><br>  # define um dataframe usando a lib pandas<br>  df = pd.DataFrame()<br>  df[&#39;repositorio&#39;] = repositorios_nomes<br>  df[&#39;linguagem&#39;] = repositorios_linguagens<br><br>  return df</pre><p>Finalmente temos a estrutura completa da classe “<em>DadosRepositorios”:</em></p><pre>import requests<br>import pandas as pd<br>from math import ceil<br><br>class DadosRepositorios:<br><br>    def __init__(self, owner):<br>        self.owner = owner<br>        self.api_base_url = &#39;https://api.github.com&#39;<br>        self.access_token = &#39;seu_token&#39;<br>        self.headers = {&#39;Authorization&#39;: &#39;Bearer &#39; + self.access_token,<br>                         &#39;X-GitHub-Api-Version&#39;: &#39;2022-11-28&#39;}<br><br>    def conta_repositorios(self,owner):<br>         url = f&#39;{self.api_base_url}/users/{owner}&#39;<br><br>        response = requests.get(url,headers=self.headers)<br><br>        total_repos = response.json()[&#39;public_repos&#39;]<br>    <br>        return total_repos<br><br>    def lista_repositorios(self):<br>        repos_list = []<br>    <br>        total_repos = self.conta_repositorios(self.owner)<br>    <br>        pages = ceil(total_repos / 30)<br>     <br>        for page_num in range(1, pages):<br>            try:<br>                url = f&#39;{self.api_base_url}/users/{self.owner}/repos?page={page_num}&#39;<br>                <br>                response = requests.get(url, headers=self.headers)<br>  <br>                repos_list.append(response.json())<br>            except:<br>                repos_list.append(None)<br>    <br>        return repos_list<br>  <br>    def nomes_repositorios(self, repos_list):<br>  <br>        repos_names = []<br>    <br>        for page in repos_list:<br>            for repo in page:<br>                try:<br>                    repos_names.append(repo[&#39;name&#39;])<br>                except:<br>                    pass<br>        return repos_names<br>    <br>    def linguagens_repositorios(self,repos_list):<br>  <br>        repos_lang = []<br>    <br>        for page in repos_list:<br>            for repo in page:<br>                try:<br>                    repos_lang.append(repo[&#39;language&#39;])<br>                except:<br>                    pass<br>        return repos_lang<br>  <br>    def cria_dataframe_linguagens(self):<br>  <br>        repositorios = self.lista_repositorios()<br>        repositorios_nomes = self.nomes_repositorios(repositorios)<br>        repositorios_linguagens = self.linguagens_repositorios(repositorios)<br>      <br>        df = pd.DataFrame()<br>        df[&#39;repositorio&#39;] = repositorios_nomes<br>        df[&#39;linguagem&#39;] = repositorios_linguagens<br>      <br>        return df</pre><p>O próximo passo será instanciar alguns objetos dessa classe para extrair os dados de diferentes contas do GitHub e armazená-los em arquivos CSV.</p><h3>Instanciando objetos da classe “DadosRepositorios”</h3><p>Na pasta raiz do projeto no VSCode criaremos uma nova pasta chamada dados. Todos os dados extraídos e salvos em CSV serão armazenados nela.</p><p>Ainda no arquivo dados_repos.py, no fim da classe DadosRepositorios adicionamos uma linha e removemos a identação. Começaremos a instanciação dos objetos desta classe para as contas da Amazon, Netflix, Spotify e Apple no GitHub.</p><p>Para cada objeto instanciado executaremos o método <em>cria_dataframe_linguagens() </em>armazenando o resultado em uma variável que receberá o <em>dataframe.</em></p><p>Então, para cada <em>dataframe </em>criado, podemos salvar seus dados em um arquivo CSV através do método <em>“to_csv()”</em> da biblioteca pandas passando como parâmetro o caminho onde queremos salvar esse arquivo, que no nosso caso será em “<em>dados/linguagens_&lt;conta&gt;”.</em></p><pre>import requests<br>import pandas as pd<br>from math import ceil<br><br>class DadosRepositorios:<br><br>...<br><br># Instanciando objetos<br><br>amazon_repo = DadosRepositorios(&#39;amzn&#39;)<br>linguagens_mais_usadas_amzn = amazon_repo.cria_dataframe_linguagens()<br><br><br>netflix_repo = DadosRepositorios(&#39;netflix&#39;)<br>linguagens_mais_usadas_netflix = netflix_repo.cria_dataframe_linguagens()<br><br><br>spotify_repo = DadosRepositorios(&#39;spotify&#39;)<br>linguagens_mais_usadas_spotify = spotify_repo.cria_dataframe_linguagens()<br><br>apple_repo = DadosRepositorios(&#39;apple&#39;)<br>linguagens_mais_usadas_apple = apple_repo.cria_dataframe_linguagens()<br><br><br># Salvando os dados em arquivos CSV<br>linguagens_mais_usadas_amzn.to_csv(&#39;dados/linguagens_amazon.csv&#39;)<br>linguagens_mais_usadas_netflix.to_csv(&#39;dados/linguagens_netflix.csv&#39;)<br>linguagens_mais_usadas_spotify.to_csv(&#39;dados/linguagens_spotify.csv&#39;)<br>linguagens_mais_usadas_apple.to_csv(&#39;dados/linguagens_apple.csv&#39;)</pre><h3>Executando a primeira parte do projeto</h3><p>No terminal, na raiz do nosso projeto, executaremos o seguinte comando:</p><pre>python3 dados_repos.py</pre><p>Para conferirmos se os dados foram extraídos, transformados e salvos em CSV, podemos abrir a pasta dados e verificar se os arquivos estão lá.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/195/1*Xyg9C-n0Uro9GO6G4Shbvg.png" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/447/1*aGspc0CZZ6R1FOIKnurvmA.png" /></figure><h3>Manipulando repositórios</h3><p>Para finalizar nosso projeto, criaremos uma nova classe, chamada <em>“ManipulaRepositorios”</em>. Ele servirá para criar um novo repositório na nossa conta no GitHub e realizar o upload dos arquivos CSV gerados na etapa anterior.</p><p>No VS Code, na raiz do projeto, criaremos o arquivo manipula_repos.py, é nele que estará nossa próxima classe.</p><p>No início do código, importamos as bibliotecas utilizadas no decorrer dos métodos, sendo elas a <em>requests</em>e a <em>base64</em>, utilizada para fazer a codificação do arquivo para a base64.</p><p>No construtor da classe adicionaremos o parâmetro <em>username</em> que receberá o nome de usuário onde criaremos o repositório para fazer o upload dos arquivos. Da mesma forma que na classe anterior, declaramos os atributos <em>api_base_url</em> , <em>access_token</em>e <em>headers</em>.</p><pre>import requests<br>import base64<br><br>class ManipulaRepositorios:<br><br>    def __init__(self, username):<br>        self.username = username<br>        self.api_base_url = &#39;https://api.github.com&#39;<br>        self.access_token = &#39;seu_token&#39;<br>        self.headers = {&#39;Authorization&#39;:&quot;Bearer &quot; + self.access_token,<br>                        &#39;X-GitHub-Api-Version&#39;: &#39;2022-11-28&#39;}</pre><p>O primeiro método que criaremos é o cria_repositorio(nome_repo), utilizado para a criação de um novo repositório. Ele recebe como parâmetro o nome_repo, ou seja, quando chamarmos esse método, temos que passar o nome do repositório que desejamos criar.</p><pre>def cria_repositorio(self, nome_repo):<br>        # define info necessárias para criacao do repositorio<br>        data = {<br>            &quot;name&quot;: nome_repo,<br>            &quot;description&quot;: &quot;Dados dos repositórios de algumas empresas&quot;,<br>            &quot;private&quot;: False<br>        }<br>      <br>        # monta o endpoint da consulta<br>        url = f&#39;{self.api_base_url}/user/repos&#39;<br><br>        # realiza a requisição POST<br>        response = requests.post(url,json=data, headers=self.headers)<br><br>        # imprime no terminal o status_code da requisicao<br>        print(f&#39;status_code criação do repositório: {response.status_code}&#39;)</pre><p>No método seguinte, faremos a codificação dos arquivos para a base64 e depois o upload para o repositório que criamos. Para isso, criaremos o método adiciona_arquivo(nome_repo, nome_arquivo, caminho_arquivo) que recebe três parâmetros.</p><p>O primeiro é o nome do repositório para o qual faremos o upload do arquivo, nome_repo. Depois o nome_arquivo que é nome que desejamos que o arquivo tenha no GitHub, seguido pelo caminho_arquivona máquina local.</p><pre>def adiciona_arquivo(self, nome_repo, nome_arquivo, caminho_arquivo):<br><br>        # Abre o arquivo no formato binario<br>        with open(caminho_arquivo, &quot;rb&quot;) as file:<br>            file_content = file.read()<br>        <br>        # Codifica o arquivo para base64<br>        encoded_content = base64.b64encode(file_content)<br><br>        # monta o endpoint de consulta<br>        url = f&#39;{self.api_base_url}/repos/{self.username}/{nome_repo}/contents/{nome_arquivo}&#39;<br>        <br>        # monta a estrutura de dados necessária passando o arquivo condificado<br>        data = {<br>                &quot;message&quot;: &quot;Adicionando um novo arquivo&quot;,<br>                &quot;content&quot;: encoded_content.decode(&quot;utf-8&quot;)<br>        }<br>        <br>        # efetua uma requisição PUT<br>        response = requests.put(url, json=data, headers=self.headers)<br><br>        # imprime o status_code da requisicao no terminal<br>        print(f&#39;status_code upload do arquivo: {response.status_code}&#39;)</pre><p>Finalmente temos a estrutura completa da classe “<em>ManipulaRepositorios”:</em></p><pre>import requests<br>import base64<br><br>class ManipulaRepositorios:<br><br>    def __init__(self, username):<br>        self.username = username<br>        self.api_base_url = &#39;https://api.github.com&#39;<br>        self.access_token = &#39;seu_token&#39;<br>        self.headers = {&#39;Authorization&#39;:&quot;Bearer &quot; + self.access_token,<br>                        &#39;X-GitHub-Api-Version&#39;: &#39;2022-11-28&#39;}<br><br>    def cria_repositorio(self, nome_repo):<br>        data = {<br>            &quot;name&quot;: nome_repo,<br>            &quot;description&quot;: &quot;Dados dos repositórios de algumas empresas&quot;,<br>            &quot;private&quot;: False<br>        }<br>     <br>        url = f&#39;{self.api_base_url}/user/repos&#39;<br><br>        response = requests.post(url,json=data, headers=self.headers)<br><br>        print(f&#39;status_code criação do repositório: {response.status_code}&#39;)<br><br>    def adiciona_arquivo(self, nome_repo, nome_arquivo, caminho_arquivo):<br><br>        with open(caminho_arquivo, &quot;rb&quot;) as file:<br>            file_content = file.read()<br>        <br>        encoded_content = base64.b64encode(file_content)<br><br>        url = f&#39;{self.api_base_url}/repos/{self.username}/{nome_repo}/contents/{nome_arquivo}&#39;<br>        <br>        data = {<br>                &quot;message&quot;: &quot;Adicionando um novo arquivo&quot;,<br>                &quot;content&quot;: encoded_content.decode(&quot;utf-8&quot;)<br>        }<br>        <br>        response = requests.put(url, json=data, headers=self.headers)<br><br>        print(f&#39;status_code upload do arquivo: {response.status_code}&#39;)</pre><h3>Criando novo repositório no GitHub</h3><p>Ainda no arquivo manipula_repos.py, no fim da classe ManipulaRepositorios adicionamos uma linha e removemos a identação.</p><p>A primeira coisa que faremos é instanciar o objeto da classe ManipulaRepositoriose adicionar o resultado à variável novo_repo. Para isso passamos como parâmetro o nome de usuário usernameda nossa conta do GitHub.</p><p>Após instanciado o objeto, chamaremos o método <em>“cria_repositorio(nome_repo)”</em> passando como parâmetro o nome que queremos dar para o repositório no GitHub.</p><pre>import requests<br>import base64<br><br>class ManipulaRepositorios:<br><br>...<br><br># Instanciando objetos<br>username = &#39;seu_username&#39;<br>novo_repo = ManipulaRepositorios(username)<br><br># Criando o repositório<br>nome_repo = &#39;linguagens-repositorios-empresas&#39;<br>novo_repo.cria_repositorio(nome_repo)</pre><h3>Adicionando arquivos no repositório criado</h3><p>Por fim, faremos o <em>upload</em> dos arquivos gerados para o repositório do GitHub. Para isso, chamaremos o método adiciona_arquivo()do objeto novo_repoe passaremos os três parâmetros esperados:</p><ol><li>O nome do repositório onde queremos fazer o <em>upload</em> do arquivo;</li><li>O nome que queremos dar para o arquivo lá no nosso repositório do GitHub;</li><li>O caminho desse arquivo na máquina para que possamos fazer o <em>upload</em> no repositório.</li></ol><pre>...<br><br># Adicionando arquivos salvos no repositório criado<br>novo_repo.adiciona_arquivo(nome_repo, &#39;linguagens_amzn.csv&#39;, &#39;dados/linguagens_amzn.csv&#39;)<br>novo_repo.adiciona_arquivo(nome_repo, &#39;linguagens_netflix.csv&#39;, &#39;dados/linguagens_netflix.csv&#39;)<br>novo_repo.adiciona_arquivo(nome_repo, &#39;linguagens_spotify.csv&#39;, &#39;dados/linguagens_spotify.csv&#39;)</pre><p>Por fim, temos o código completo manipula_repos.py que realiza a criação de repositório no GitHub e o upload dos arquivos CSV criados na etapa anterior.</p><pre>import requests<br>import base64<br><br>class ManipulaRepositorios:<br><br>...<br><br># Instanciando objetos<br>username = &#39;seu_username&#39;<br>novo_repo = ManipulaRepositorios(username)<br><br># Criando o repositório<br>nome_repo = &#39;linguagens-repositorios-empresas&#39;<br>novo_repo.cria_repo(nome_repo)<br><br># Adicionando arquivos salvos no repositório criado<br>novo_repo.adiciona_arquivo(nome_repo, &#39;linguagens_amzn.csv&#39;, &#39;dados/linguagens_amzn.csv&#39;)<br>novo_repo.adiciona_arquivo(nome_repo, &#39;linguagens_netflix.csv&#39;, &#39;dados/linguagens_netflix.csv&#39;)<br>novo_repo.adiciona_arquivo(nome_repo, &#39;linguagens_spotify.csv&#39;, &#39;dados/linguagens_spotify.csv&#39;)</pre><h3>Executando a segunda parte do projeto</h3><p>No terminal, na raiz do nosso projeto, executaremos o seguinte comando:</p><pre>python3 manipula_repos.py</pre><p>Agora, para conferir, acessamos a nossa conta pessoal do GitHub. Ao clicarmos na seção “Repositories” encontramos o novo repositório chamado linguagens-repositorios-empresas seguido da descrição que colocamos, Dados dos repositórios de algumas empresas.</p><p>Ele está identificado como público, pois fizemos assim. Ao clicar nele, encontramos os 4 arquivos que fizemos <em>upload:</em> linguagens-amzn.csv, linguagens-netflix.csv , linguagens-spotify.csve linguagens-apple.csv.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/534/1*Ypgsf9GPgy7pG87aQVgLVg.png" /></figure><p>Ao acessar o arquivo da Amazon, garantimos que está tudo estruturado conforme esperávamos. Encontramos a tabela com as colunas, repositorio e linguagem.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/524/1*z9j_VscWrArkyrrpnlTW5Q.png" /></figure><h3><strong>Assim finalizamos nosso projeto!</strong></h3><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=6100dec91ab4" width="1" height="1" alt="">]]></content:encoded>
        </item>
    </channel>
</rss>