Como criar visualizações de dados de atualização automática em Python com IEX Cloud, Matplotlib e AWS

PorAntónio César de Andrade 

tickers = [
            'JPM',
            'BAC',
            'C',
            'WFC',
            'GS',
            ]

A API da nuvem IEX aceita tickers separados por vírgulas. Precisamos serializar nossa lista de tickers em uma sequência separada de tickers. Aqui está o código que usaremos para fazer isso:

#Create an empty string called `ticker_string` that we'll add tickers and commas to
ticker_string = ''

#Loop through every element of `tickers` and add them and a comma to ticker_string
for ticker in tickers:
    ticker_string += ticker
    ticker_string += ','
    
#Drop the last comma from `ticker_string`
ticker_string = ticker_string[:-1]

A próxima tarefa que precisamos executar é selecionar qual terminal da API da nuvem IEX precisamos executar ping.

Uma rápida revisão da documentação da IEX Cloud revela que eles têm uma Historical Prices endpoint, para o qual podemos enviar uma solicitação HTTP usando o charts palavra-chave

Também precisaremos especificar a quantidade de dados que estamos solicitando (medida em anos).

Para direcionar esse terminal para o intervalo de dados especificado, eu armazenei o charts ponto final e a quantidade de tempo em variáveis ​​separadas. Esses pontos de extremidade são interpolados no URL serializado que usaremos para enviar nossa solicitação de HTTP.

Aqui está o código:

#Create the endpoint and years strings
endpoints = 'charts'
years = '10'

#Interpolate the endpoint strings into the HTTP_request string
HTTP_request = f'https://cloud.iexapis.com/stable/stock/market/batch?symbols={ticker_string}&types={endpoints}&range={years}y&token={IEX_API_Key}'

Essa sequência interpolada é importante porque nos permite alterar facilmente o valor de nossa sequência posteriormente, sem alterar cada ocorrência da sequência em nossa base de código.

Agora é hora de realmente fazer nossa solicitação HTTP e armazenar os dados em uma estrutura de dados em nossa máquina local.

Para fazer isso, vou usar a biblioteca de pandas para Python. Especificamente, os dados serão armazenados em um pandas DataFrame.

Primeiro, precisamos importar o pandas biblioteca. Por convenção, os pandas são normalmente importados sob o alias pd. Adicione o seguinte código ao início do seu script para importar pandas com o alias desejado:

import pandas as pd

Depois de importar os pandas para o script Python, podemos usar seu read_json método para armazenar os dados da nuvem IEX em um DataFrame do pandas:

bank_data = pd.read_json(HTTP_request)

Imprimir este DataFrame dentro de um Jupyter Notebook gera a seguinte saída:

É claro que não é isso que queremos. Precisamos analisar esses dados para gerar um DataFrame que vale a pena plotar.

Para começar, vamos examinar uma coluna específica de bank_data – digamos, bank_data['JPM']:

Está claro que a próxima camada de análise precisará ser a chart ponto final:

Agora, temos uma estrutura de dados semelhante a JSON, em que cada célula é uma data, juntamente com vários pontos de dados sobre o preço das ações do JPM nessa data.

Podemos agrupar essa estrutura semelhante a JSON em um DataFrame do pandas para torná-la muito mais legível:

É algo com que podemos trabalhar!

Vamos escrever um pequeno loop que usa lógica semelhante para extrair a série temporal de preços de fechamento de cada ação como um pandas Series (que é equivalente a uma coluna de um DataFrame do pandas). Armazenaremos essas séries de pandas em um dicionário (com a chave sendo o nome do ticker) para facilitar o acesso posteriormente.

for ticker in tickers:
    series_dict.update( {ticker : pd.DataFrame(bank_data[ticker]['chart'])['close']} )

Agora podemos criar nosso DataFrame finalizado do panda que tem a data como seu índice e uma coluna para o preço de fechamento de todas as principais ações bancárias nos últimos 5 anos:

series_list = []

for ticker in tickers:
    series_list.append(pd.DataFrame(bank_data[ticker]['chart'])['close'])

series_list.append(pd.DataFrame(bank_data['JPM']['chart'])['date'])

column_names = tickers.copy()
column_names.append('Date')

bank_data = pd.concat(series_list, axis=1)
bank_data.columns = column_names

bank_data.set_index('Date', inplace = True)

Depois de tudo isso feito, nosso bank_data O DataFrame ficará assim:

Nossa coleta de dados está completa. Agora estamos prontos para começar a criar visualização com esse conjunto de dados de preços de ações para bancos de capital aberto. Como uma rápida recapitulação, aqui está o script que criamos até agora:

import pandas as pd
import matplotlib.pyplot as plt

IEX_API_Key = ''

tickers = [
            'JPM',
            'BAC',
            'C',
            'WFC',
            'GS',
            ]

#Create an empty string called `ticker_string` that we'll add tickers and commas to
ticker_string = ''

#Loop through every element of `tickers` and add them and a comma to ticker_string
for ticker in tickers:
    ticker_string += ticker
    ticker_string += ','
    
#Drop the last comma from `ticker_string`
ticker_string = ticker_string[:-1]

#Create the endpoint and years strings
endpoints = 'chart'
years = '5'

#Interpolate the endpoint strings into the HTTP_request string
HTTP_request = f'https://cloud.iexapis.com/stable/stock/market/batch?symbols={ticker_string}&types={endpoints}&range={years}y&cache=true&token={IEX_API_Key}'

#Send the HTTP request to the IEX Cloud API and store the response in a pandas DataFrame
bank_data = pd.read_json(HTTP_request)

#Create an empty list that we will append pandas Series of stock price data into
series_list = []

#Loop through each of our tickers and parse a pandas Series of their closing prices over the last 5 years
for ticker in tickers:
    series_list.append(pd.DataFrame(bank_data[ticker]['chart'])['close'])

#Add in a column of dates
series_list.append(pd.DataFrame(bank_data['JPM']['chart'])['date'])

#Copy the 'tickers' list from earlier in the script, and add a new element called 'Date'. 
#These elements will be the column names of our pandas DataFrame later on.
column_names = tickers.copy()
column_names.append('Date')

#Concatenate the pandas Series together into a single DataFrame
bank_data = pd.concat(series_list, axis=1)

#Name the columns of the DataFrame and set the 'Date' column as the index
bank_data.columns = column_names
bank_data.set_index('Date', inplace = True)

Etapa 2: criar o gráfico que você deseja atualizar

Neste tutorial, trabalharemos com a biblioteca de visualização matplotlib para Python.

O Matplotlib é uma biblioteca tremendamente sofisticada e as pessoas passam anos dominando-a em toda a sua extensão. Portanto, lembre-se de que estamos apenas arranhando a superfície dos recursos do matplotlib neste tutorial.

Começaremos importando a biblioteca matplotlib.

Como importar Matplotlib

Por convenção, os cientistas de dados geralmente importam o pyplot biblioteca de matplotlib sob o alias plt.

Aqui está a declaração de importação completa:

import matplotlib.pyplot as plt

Você precisará incluir isso no início de qualquer arquivo Python que use matplotlib para gerar visualizações de dados.

Também existem outros argumentos que você pode adicionar à importação da biblioteca matplotlib para facilitar o trabalho de visualização.

Se você estiver trabalhando neste tutorial em um Notebook Jupyter, inclua a seguinte declaração, que fará com que suas visualizações apareçam sem a necessidade de escrever um plt.show() declaração:

%matplotlib inline

Se você estiver trabalhando em um notebook Jupyter em um MacBook com uma tela retina, poderá usar as seguintes instruções para melhorar a resolução de suas visualizações matplotlib no notebook:

from IPython.display import set_matplotlib_formats

set_matplotlib_formats('retina')

Com isso fora do caminho, vamos começar a criar nossas primeiras visualizações de dados usando Python e matplotlib!

Fundamentos de formatação do Matplotlib

Neste tutorial, você aprenderá como criar gráficos de caixa, gráficos de dispersão e histogramas no Python usando matplotlib. Quero passar por algumas noções básicas de formatação no matplotlib antes de começar a criar visualizações de dados reais.

Primeiro, quase tudo o que você faz no matplotlib envolve a chamada de métodos no plt objeto, que é o alias ao qual importamos o matplotlib.

Segundo, você pode adicionar títulos às visualizações matplotlib chamando plt.title() e passando o título desejado como uma string.

Terceiro, você pode adicionar etiquetas aos eixos x e y usando o plt.xlabel() e plt.ylabel() métodos.

Por fim, com os três métodos que acabamos de discutir – plt.title(), plt.xlabel()e plt.ylabel() – você pode alterar o tamanho da fonte do título com o fontsize argumento.

Vamos nos aprofundar na criação de nossas primeiras visualizações matplotlib.

Como criar Boxplots no Matplotlib

Boxplots são uma das visualizações de dados mais fundamentais disponíveis para os cientistas de dados.

O Matplotlib nos permite criar boxplots com o boxplot função.

Como criaremos boxplots ao longo de nossas colunas (e não ao longo de nossas linhas), também desejaremos transpor nosso DataFrame para dentro do boxplot chamada de método.

plt.boxplot(bank_data.transpose())

Este é um bom começo, mas precisamos adicionar alguns estilos para tornar essa visualização facilmente interpretável para um usuário externo.

Primeiro, vamos adicionar um título do gráfico:

plt.title('Boxplot of Bank Stock Prices (5Y Lookback)', fontsize = 20)

Ademais, é útil rotular os eixos x e y, como mencionado anteriormente:

plt.xlabel('Bank', fontsize = 20)
plt.ylabel('Stock Prices', fontsize = 20)

Também precisaremos adicionar rótulos específicos da coluna ao eixo x para que fique claro qual boxplot pertence a cada banco.

O código a seguir faz o truque:

ticks = range(1, len(bank_data.columns)+1)
labels = list(bank_data.columns)
plt.xticks(ticks,labels, fontsize = 20)

Assim, temos um boxplot que apresenta algumas visualizações úteis no matplotlib! É claro que o Goldman Sachs negociou ao preço mais alto nos últimos 5 anos, enquanto as ações do Bank of America negociaram ao preço mais baixo. Também é interessante notar que o Wells Fargo possui os pontos de dados mais extremos.

Como uma recapitulação, aqui está o código completo que usamos para gerar nossos boxplots:

########################
#Create a Python boxplot
########################

#Set the size of the matplotlib canvas
plt.figure(figsize = (18,12))

#Generate the boxplot
plt.boxplot(bank_data.transpose())

#Add titles to the chart and axes
plt.title('Boxplot of Bank Stock Prices (5Y Lookback)', fontsize = 20)
plt.xlabel('Bank', fontsize = 20)
plt.ylabel('Stock Prices', fontsize = 20)

#Add labels to each individual boxplot on the canvas
ticks = range(1, len(bank_data.columns)+1)
labels = list(bank_data.columns)
plt.xticks(ticks,labels, fontsize = 20)

Como criar gráficos de dispersão no Matplotlib

Gráficos de dispersão pode ser criado no matplotlib usando o plt.scatter método.

o scatter O método possui dois argumentos obrigatórios – um x valor e um y valor.

Vamos traçar o preço das ações da Wells Fargo ao longo do tempo usando o plt.scatter() método.

A primeira coisa que precisamos fazer é criar nossa variável de eixo x, chamada dates:

dates = bank_data.index.to_series()

Em seguida, isolaremos os preços das ações da Wells Fargo em uma variável separada:

WFC_stock_prices =  bank_data['WFC']

Agora podemos plotar a visualização usando o plt.scatter método:

plt.scatter(dates, WFC_stock_prices)

Espere um minuto – é impossível ler os rótulos x deste gráfico!

Qual é o problema?

Bem, o matplotlib não está reconhecendo atualmente que o eixo x contém datas, portanto, não está espaçando os rótulos corretamente.

Para consertar isso, precisamos transformar todos os elementos do dates Série em um datetime tipo de dados. O comando a seguir é a maneira mais legível de fazer isso:

dates = bank_data.index.to_series()
dates = [pd.to_datetime(d) for d in dates]

Depois de executar o plt.scatter método novamente, você irá gerar a seguinte visualização:

Muito melhor!

Nosso último passo é adicionar títulos ao gráfico e ao eixo. Podemos fazer isso com as seguintes declarações:

plt.title("Wells Fargo Stock Price (5Y Lookback)", fontsize=20)
plt.ylabel("Stock Price", fontsize=20)
plt.xlabel("Date", fontsize=20)

Como recapitulação, eis o código que usamos para criar este gráfico de dispersão:

########################
#Create a Python scatterplot
########################

#Set the size of the matplotlib canvas
plt.figure(figsize = (18,12))

#Create the x-axis data
dates = bank_data.index.to_series()
dates = [pd.to_datetime(d) for d in dates]

#Create the y-axis data
WFC_stock_prices =  bank_data['WFC']

#Generate the scatterplot
plt.scatter(dates, WFC_stock_prices)

#Add titles to the chart and axes
plt.title("Wells Fargo Stock Price (5Y Lookback)", fontsize=20)
plt.ylabel("Stock Price", fontsize=20)
plt.xlabel("Date", fontsize=20)

Como criar histogramas no Matplotlib

Histogramas são visualizações de dados que permitem ver a distribuição das observações em um conjunto de dados.

Os histogramas podem ser criados no matplotlib usando o método plt.hist método.

Vamos criar um histograma que nos permita ver a distribuição dos diferentes preços das ações em nosso bank_data conjunto de dados (observe que precisaremos usar o transpose método dentro plt.hist assim como fizemos com plt.boxplot anteriormente):

plt.hist(bank_data.transpose())

Essa é uma visualização interessante, mas ainda temos muito o que fazer.

A primeira coisa que você provavelmente notou foi que as diferentes colunas do histograma têm cores diferentes. Isso é intencional. As cores dividem as diferentes colunas no DataFrame do panda.

Com isso dito, essas cores são sem sentido sem uma lenda. Podemos adicionar uma legenda ao nosso histograma matplotlib com a seguinte declaração:

plt.legend(bank_data.columns,fontsize=20)

Você também pode alterar o bin count do histograma, que altera em quantas fatias o conjunto de dados é dividido ao agrupar as observações em colunas de histograma.

Como exemplo, veja como alterar o número de bins no histograma para 50:

plt.hist(bank_data.transpose(), bins = 50)

Por fim, adicionaremos títulos ao histograma e seus eixos usando as mesmas instruções que usamos em nossas outras visualizações:

plt.title("A Histogram of Daily Closing Stock Prices for the 5 Largest Banks in the US (5Y Lookback)", fontsize = 20)
plt.ylabel("Observations", fontsize = 20)
plt.xlabel("Stock Prices", fontsize = 20)

Como uma recapitulação, aqui está o código completo necessário para gerar este histograma:

########################
#Create a Python histogram
########################

#Set the size of the matplotlib canvas
plt.figure(figsize = (18,12))

#Generate the histogram
plt.hist(bank_data.transpose(), bins = 50)

#Add a legend to the histogram
plt.legend(bank_data.columns,fontsize=20)

#Add titles to the chart and axes
plt.title("A Histogram of Daily Closing Stock Prices for the 5 Largest Banks in the US (5Y Lookback)", fontsize = 20)
plt.ylabel("Observations", fontsize = 20)
plt.xlabel("Stock Prices", fontsize = 20)

Como criar subtramas no Matplotlib

No matplotlib, subparcelas é o nome que usamos para nos referir a vários gráficos criados na mesma tela usando um único script Python.

As subparcelas podem ser criadas com o plt.subplot comando. O comando usa três argumentos:

  • O número de linhas em uma grade de subparcela
  • O número de colunas em uma grade de subparcela
  • Qual subtrama você selecionou atualmente

Vamos criar uma grade de subparcela 2×2 que contém os seguintes gráficos (nesta ordem específica):

  1. O boxplot que criamos anteriormente
  2. O gráfico de dispersão que criamos anteriormente
  3. Um gráfico de dispersão semelhante que usa BAC dados em vez de WFC dados
  4. O histograma que criamos anteriormente

Primeiro, vamos criar a grade de subparcela:

plt.subplot(2,2,1)

plt.subplot(2,2,2)

plt.subplot(2,2,3)

plt.subplot(2,2,4)

Agora que temos uma tela de subparcela em branco, basta copiar / colar o código necessário para cada plotagem após cada chamada do plt.subplot método.

No final do bloco de código, adicionamos o plt.tight_layout , que corrige muitos problemas comuns de formatação que ocorrem ao gerar subtramas matplotlib.

Aqui está o código completo:

################################################
################################################
#Create subplots in Python
################################################
################################################

########################
#Subplot 1
########################
plt.subplot(2,2,1)

#Generate the boxplot
plt.boxplot(bank_data.transpose())

#Add titles to the chart and axes
plt.title('Boxplot of Bank Stock Prices (5Y Lookback)')
plt.xlabel('Bank', fontsize = 20)
plt.ylabel('Stock Prices')

#Add labels to each individual boxplot on the canvas
ticks = range(1, len(bank_data.columns)+1)
labels = list(bank_data.columns)
plt.xticks(ticks,labels)

########################
#Subplot 2
########################
plt.subplot(2,2,2)

#Create the x-axis data
dates = bank_data.index.to_series()
dates = [pd.to_datetime(d) for d in dates]

#Create the y-axis data
WFC_stock_prices =  bank_data['WFC']

#Generate the scatterplot
plt.scatter(dates, WFC_stock_prices)

#Add titles to the chart and axes
plt.title("Wells Fargo Stock Price (5Y Lookback)")
plt.ylabel("Stock Price")
plt.xlabel("Date")

########################
#Subplot 3
########################
plt.subplot(2,2,3)

#Create the x-axis data
dates = bank_data.index.to_series()
dates = [pd.to_datetime(d) for d in dates]

#Create the y-axis data
BAC_stock_prices =  bank_data['BAC']

#Generate the scatterplot
plt.scatter(dates, BAC_stock_prices)

#Add titles to the chart and axes
plt.title("Bank of America Stock Price (5Y Lookback)")
plt.ylabel("Stock Price")
plt.xlabel("Date")

########################
#Subplot 4
########################
plt.subplot(2,2,4)

#Generate the histogram
plt.hist(bank_data.transpose(), bins = 50)

#Add a legend to the histogram
plt.legend(bank_data.columns,fontsize=20)

#Add titles to the chart and axes
plt.title("A Histogram of Daily Closing Stock Prices for the 5 Largest Banks in the US (5Y Lookback)")
plt.ylabel("Observations")
plt.xlabel("Stock Prices")

plt.tight_layout()

Como você pode ver, com alguns conhecimentos básicos, é relativamente fácil criar belas visualizações de dados usando o matplotlib.

A última coisa que precisamos fazer é salvar a visualização como um .png no nosso diretório de trabalho atual. O Matplotlib possui uma excelente funcionalidade integrada para fazer isso. Basta adicionar a instrução a seguir imediatamente após a finalização do quarto subtrama:

################################################
#Save the figure to our local machine
################################################

plt.savefig('bank_data.png')

No restante deste tutorial, você aprenderá como agendar essa matriz de subtrama para ser atualizada automaticamente em seu site ao vivo todos os dias.

Etapa 3: criar uma conta Amazon Web Services

Até agora neste tutorial, aprendemos como:

  • Obtenha os dados do mercado de ações que vamos visualizar a partir da API da nuvem IEX
  • Crie visualizações maravilhosas usando esses dados com a biblioteca matplotlib para Python

No restante deste tutorial, você aprenderá como automatizar essas visualizações para que sejam atualizadas em uma programação específica.

Para fazer isso, usaremos os recursos de computação em nuvem do Amazon Web Services. Você precisará criar uma conta da AWS primeiro.

Navegar para este URL e clique em “Criar uma conta da AWS” no canto superior direito:

O aplicativo da web da AWS guiará você pelas etapas para criar uma conta.

Depois que sua conta for criada, podemos começar a trabalhar com os dois serviços da AWS necessários para nossas visualizações: AWS S3 e AWS EC2.

Etapa 4: criar um bucket do AWS S3 para armazenar suas visualizações

AWS S3 significa Serviço de Armazenamento Simples. É uma das ofertas mais populares de computação em nuvem disponíveis no Amazon Web Services. Os desenvolvedores usam o AWS S3 para armazenar arquivos e acessá-los posteriormente por meio de URLs voltadas ao público.

Para armazenar esses arquivos, primeiro precisamos criar o que é chamado de AWS S3 bucket, que é uma palavra elegante para uma pasta que armazena arquivos na AWS. Para fazer isso, navegue primeiro para o painel S3 no Amazon Web Services.

No lado direito do painel do Amazon S3, clique em Create bucket, como mostrado abaixo:

Na próxima tela, a AWS solicitará que você selecione um nome para o seu novo bucket do S3. Para os fins deste tutorial, usaremos o nome do bloco nicks-first-bucket.

Em seguida, você precisará rolar para baixo e definir suas permissões de bucket. Como os arquivos que enviaremos foram projetados para serem acessíveis ao público (afinal, vamos incorporá-los nas páginas de um site), convém tornar as permissões o mais abertas possível.

Aqui está um exemplo específico de como devem ser suas permissões do AWS S3:

Essas permissões são muito frouxas e, para muitos casos de uso, não são aceitáveis ​​(embora elas realmente atendam aos requisitos deste tutorial). Por esse motivo, a AWS exigirá que você confirme o seguinte aviso antes de criar seu bucket do AWS S3:

Feito tudo isso, você pode rolar para a parte inferior da página e clicar em Create Bucket. Agora você está pronto para prosseguir!

Etapa 5: modificar o script Python para salvar suas visualizações no AWS S3

Nosso script Python em sua forma atual é projetado para criar uma visualização e, em seguida, salvá-la no computador local. Agora precisamos modificar nosso script para salvar o arquivo .png arquivo para o bucket do AWS S3 que acabamos de criar (que, como lembrete, é chamado nicks-first-bucket)

A ferramenta que usaremos para fazer upload de nosso arquivo para nosso bucket do AWS S3 é chamada boto3, que é o SDK (Amazon Web Services Software Development Kit) para Python.

Primeiro, você precisará instalar boto3 na sua máquina. A maneira mais fácil de fazer isso é usar o pip gerenciador de pacotes:

pip3 install boto3

Em seguida, precisamos importar boto3 no nosso script Python. Fazemos isso adicionando a seguinte declaração no início do nosso script:

import boto3

Dada a profundidade e amplitude das ofertas de produtos da Amazon Web Services, boto3 é uma biblioteca Python incrivelmente complexa.

Felizmente, precisamos usar apenas algumas das funcionalidades mais básicas do boto3.

O seguinte bloco de código fará o upload da nossa visualização final para o Amazon S3.

################################################
#Push the file to the AWS S3 bucket
################################################

s3 = boto3.resource('s3')
s3.meta.client.upload_file('bank_data.png', 'nicks-first-bucket', 'bank_data.png', ExtraArgs={'ACL':'public-read'})

Como você pode ver, o upload_file método de boto3 leva vários argumentos. Vamos dividi-los, um por um:

  1. bank_data.png é o nome do arquivo em nossa máquina local.
  2. nicks-first-bucket é o nome do bloco S3 para o qual queremos fazer upload.
  3. bank_data.png é o nome que queremos que o arquivo tenha depois de ser carregado no bucket do AWS S3. Nesse caso, é o mesmo que o primeiro argumento, mas não precisa ser.
  4. ExtraArgs={'ACL':'public-read'} significa que o arquivo deve ser legível pelo público assim que for enviado para o bucket do AWS S3.

A execução desse código agora resultará em um erro. Especificamente, o Python lançará a seguinte exceção:

S3UploadFailedError: Failed to upload bank_data.png to nicks-first-bucket/bank_data.png: An error occurred (NoSuchBucket) when calling the PutObject operation: The specified bucket does not exist

Por que é isso?

Bem, é porque ainda não configuramos nossa máquina local para interagir com o Amazon Web Services por meio de boto3. Para fazer isso, precisamos executar o aws configure comando da nossa interface de linha de comando e adicione nossas chaves de acesso. Este documento da Amazon compartilha mais informações sobre como configurar sua interface de linha de comando da AWS.

Se você preferir não sair do freecodecamp.org, aqui estão as etapas rápidas para configurar sua CLI da AWS.

Primeiro, passe o mouse sobre o seu nome de usuário no canto superior direito, assim:

Clique My Security Credentials.

Na próxima tela, você vai querer clicar no Access keys (access key ID and secret access key suspensa e clique em Create New Access Key.

Isso solicitará que você baixe um .csv arquivo que contém sua chave de acesso e sua chave de acesso secreta. Salve-os em um local seguro.

Em seguida, ative a interface da linha de comando do Amazon Web Services digitando aws configure na sua linha de comando. Isso solicitará que você insira sua Chave de acesso e Chave de acesso secreta.

Feito isso, seu script deve funcionar como pretendido. Execute novamente o script e verifique se a visualização do Python foi carregada corretamente no AWS S3, procurando dentro do bucket que criamos anteriormente:

A visualização foi carregada com sucesso. Agora estamos prontos para incorporar a visualização em nosso site!

Etapa 6: incorporar a visualização no seu site

Depois que a visualização de dados tiver sido carregada no AWS S3, convém incorporar a visualização em algum lugar do seu site. Isso pode estar em uma postagem do blog ou em qualquer outra página do seu site.

Para fazer isso, precisaremos pegar o URL da imagem do nosso bucket S3. Clique no nome da imagem no intervalo S3 para navegar para a página específica do arquivo para esse item. Isso parecerá assim:

Se você rolar até o final da página, haverá um campo chamado Object URL que se parece com isso:

https://nicks-first-bucket.s3.us-east-2.amazonaws.com/bank_data.png

Se você copiar e colar esse URL em um navegador da Web, ele realmente fará o download do bank_data.png arquivo que enviamos anteriormente!

Para incorporar esta imagem em uma página da web, você deve passá-la para um HTML img tag como o src atributo. Aqui está como incorporaríamos nosso bank_data.png imagem em uma página da web usando HTML:

Nota: Em uma imagem real incorporada em um site, seria importante incluir um alt tag para fins de acessibilidade.

Na próxima seção, aprenderemos como agendar nosso script Python para ser executado periodicamente, para que os dados em bank_data.png está sempre atualizado.

Etapa 7: criar uma instância do AWS EC2

Usaremos o AWS EC2 para agendar nosso script Python para execução periódica.

AWS EC2 significa Elastic Compute Cloud e, juntamente com o S3, é um dos serviços de computação em nuvem mais populares da Amazon.

Ele permite que você alugue pequenas unidades de energia computacional (chamadas instâncias) em computadores nos datacenters da Amazon e agende esses computadores para executar tarefas para você.

O AWS EC2 é um serviço bastante incrível, porque se você alugar alguns de seus computadores menores, estará qualificado para o nível gratuito da AWS. Dito de forma diferente, o uso diligente dos preços no AWS EC2 permitirá que você evite pagar qualquer dinheiro.

Para começar, precisamos criar nossa primeira instância do EC2. Para fazer isso, navegue até o painel do EC2 no AWS Management Console e clique em Launch Instance:

Isso levará você a uma tela que contém todos os tipos de instância disponíveis no AWS EC2. Há um número quase inacreditável de opções aqui. Queremos um tipo de instância que se qualifique como Free tier eligible – especificamente, eu escolhi o Amazon Linux 2 AMI (HVM), SSD Volume Type:

Clique Select para prosseguir.

Na próxima página, a AWS solicitará que você selecione as especificações para sua máquina. Os campos que você pode selecionar incluem:

  • Family
  • Type
  • vCPUs
  • Memory
  • Instance Storage (GB)
  • EBS-Optimized
  • Network Performance
  • IPv6 Support

Para os fins deste tutorial, queremos simplesmente selecionar a máquina única qualificada para o nível gratuito. É caracterizada por um pequeno rótulo verde que se parece com isso:

Clique Review and Launch na parte inferior da tela para continuar.

A próxima tela apresentará os detalhes da sua nova instância para você revisar.

Revise rapidamente as especificações da máquina e clique em Launch no canto inferior direito.

Clicando no Launch O botão acionará um pop-up solicitando que você Select an existing key pair or create a new key pair.

Um par de chaves é composto por uma chave pública que a AWS mantém e uma chave privada que você deve baixar e armazenar em um .pem Arquivo.

Você deve ter acesso a isso .pem para acessar sua instância do EC2 (normalmente via SSH). Você também tem a opção de continuar sem um par de chaves, mas isso é não recomendado por razões de segurança.

Feito isso, sua instância será iniciada! Parabéns por iniciar sua primeira instância em um dos serviços de infraestrutura mais importantes da Amazon Web Services.

Em seguida, você precisará enviar o script Python à sua instância do EC2.

Aqui está uma instrução genérica de estado de comando que permite mover um arquivo para uma instância do EC2:

scp -i path/to/.pem_file path/to/file   username@host_address.amazonaws.com:/path_to_copy

Execute esta declaração com as substituições necessárias para mover bank_stock_data.py na instância do EC2.

Você pode acreditar que agora pode executar seu script Python de dentro da sua instância do EC2. Infelizmente, esse não é o caso. Sua instância do EC2 não vem com os pacotes Python necessários.

Para instalar os pacotes que usamos, você pode exportar um requirements.txt arquivo e importe os pacotes adequados usando pip, ou você pode simplesmente executar o seguinte:

sudo yum install python3-pip
pip3 install pandas
pip3 install boto3

Agora estamos prontos para agendar nosso script Python para execução periódica em nossa instância do EC2! Exploramos isso na próxima seção do nosso artigo.

Etapa 8: agende o script Python para ser executado periodicamente no AWS EC2

A única etapa que resta neste tutorial é agendar nossa bank_stock_data.py para executar periodicamente em nossa instância do EC2.

Podemos usar um utilitário de linha de comando chamado cron para fazer isso.

cron funciona exigindo que você especifique duas coisas:

  • Com que frequência você deseja uma tarefa (chamada de cron job) Executada, expressa por meio de uma expressão cron
  • O que precisa ser executado quando o trabalho cron é agendado

Primeiro, vamos começar criando uma expressão cron.

cron expressões podem parecer sem sentido para alguém de fora. Por exemplo, aqui está o cron expressão que significa “todos os dias ao meio-dia”:

00 12 * * *

Eu pessoalmente uso o guru do crontab site, que é um excelente recurso que permite que você veja (em termos leigos) qual é a sua cron expressão significa.

Veja como você pode usar o site do crontab guru para agendar um trabalho cron para ser executado todos os domingos às 7h:

Agora temos uma ferramenta (crontab guru) que podemos usar para gerar nosso cron expressão. Agora precisamos instruir o cron daemon da nossa instância do EC2 para executar nosso bank_stock_data.py arquivo todos os domingos às 7h.

Para fazer isso, primeiro criaremos um novo arquivo em nossa instância do EC2 chamado bank_stock_data.cron. Desde que eu uso o vim editor de texto, o comando que eu uso para isso é:

vim bank_stock_data.cron

Dentro disto .cron arquivo, deve haver uma linha parecida com esta: (cron expression) (statement to execute). Nosso cron expressão é 00 7 * * 7 e nossa declaração para executar é python3 bank_stock_data.py.

Juntando tudo, e aqui está o conteúdo final de bank_stock_data.cron deveria estar:

00 7 * * 7 python3 bank_stock_data.py

A etapa final deste tutorial é importar o bank_stock_data.cron arquivo no crontab da nossa instância do EC2. o crontab é essencialmente um arquivo que agrupa tarefas para o cron daemon para executar periodicamente.

Vamos primeiro dedicar um momento para investigar o que em nossa crontab. O comando a seguir imprime o conteúdo do crontab para o nosso console:

crontab -l

Como não adicionamos nada ao nosso crontab e criamos nossa instância do EC2 apenas alguns momentos atrás, essa declaração não deve imprimir nada.

Agora vamos importar bank_stock_data.cron no crontab. Aqui está a declaração para fazer isso:

crontab bank_stock_data.cron

Agora devemos poder imprimir o conteúdo da nossa crontab e veja o conteúdo de bank_stock_data.cron.

Para testar isso, execute o seguinte comando:

crontab -l

Deve imprimir:

00 7 * * 7 python3 bank_stock_data.py

Pensamentos finais

Neste tutorial, você aprendeu como criar belas visualizações de dados usando Python e Matplotlib que são atualizados periodicamente. Discutimos especificamente:

  • Como baixar e analisar dados do IEX Cloud, uma das minhas fontes de dados favoritas para dados financeiros de alta qualidade
  • Como formatar dados em um DataFrame do pandas
  • Como criar visualizações de dados em Python usando matplotlib
  • Como criar uma conta no Amazon Web Services
  • Como fazer upload de arquivos estáticos para o AWS S3
  • Como incorporar .png arquivos hospedados no AWS S3 em páginas em um site
  • Como criar uma instância do AWS EC2
  • Como agendar um script Python para ser executado periodicamente usando o AWS EC2 usando cron

Este artigo foi publicado por Nick McCullum, que ensina as pessoas a codificar em seu site.