Como criar planilhas do Excel com atualização automática de dados do mercado de ações com Python, AWS e IEX Cloud

Os US $ 9 / mês Lançamento O plano é suficiente para muitos casos de uso.

Um aviso sobre o uso da nuvem IEX (e qualquer outro provedor de dados pay-per-use): é muito importante que você defina os orçamentos de uso desde o início. Esses orçamentos impedem você de acessar sua conta depois de atingir um determinado custo em dólar durante o mês.

Quando comecei a usar o IEX Cloud, criei acidentalmente um loop infinito em uma tarde de sexta-feira que continha uma chamada de API para o IEX Cloud. O preço dessas chamadas de API é baseado no custo por chamada … o que resultou em um e-mail aterrorizante da IEX:

É uma prova da centralidade do cliente da IEX que eles concordaram em redefinir meu uso desde que eu estabeleça orçamentos de uso daqui para frente. Go IEX!

Como na maioria das assinaturas de API, o principal benefício da criação de uma conta na IEX Cloud é ter uma chave de API.

Por razões óbvias, não compartilharei uma chave de API neste artigo.

No entanto, você ainda pode trabalhar neste tutorial com sua própria chave de API, desde que seja atribuída ao seguinte nome de variável:

IEX_API_Key

Você verá o espaço em branco IEX_API_Key variável nos meus blocos de código em todo o restante deste tutorial.

Etapa 2: escreva seu script Python

Agora que você tem acesso à chave da API que precisa para reunir dados financeiros, é hora de escrever seu script Python.

Esta será a seção mais longa deste tutorial. Também é o mais flexível – vamos criar um script Python que atenda a certos critérios pré-especificados, mas você pode modificar esta seção para criar realmente qualquer planilha que desejar!

Para começar, vamos mostrar nossas postagens de meta. Vamos escrever um script Python que gera um arquivo Excel de dados do mercado de ações com as seguintes características:

• Incluirá as 10 maiores ações nos Estados Unidos
• Ele conterá quatro colunas: registro de ações, nome da empresa, preço das ações e rendimento de dividendos.
• Ele será formatado de forma que a cor de fundo do cabeçalho seja #135485 e o texto é branco, enquanto o fundo do corpo da planilha é #DADADA e a cor da fonte é preta (o padrão).

Vamos começar importando nosso primeiro pacote.

Como as planilhas são essencialmente apenas estruturas de dados com linhas e colunas, o pandas biblioteca – incluindo o seu DataFrame objeto – é um candidato perfeito para manipular dados neste tutorial.

Começaremos importando pandas sob o pseudônimo pd como isso:

import pandas as pd

Em seguida, especificaremos nossa chave da API IEX Cloud. Como mencionei antes, não incluirei minha chave de API, então você terá que pegar sua própria chave de API da sua conta IEX e incluí-la aqui:

IEX_API_Key = ''

Nosso próximo passo é determinar as dez maiores empresas dos Estados Unidos.

Você pode responder a esta pergunta com uma rápida pesquisa no Google.

Por uma questão de brevidade, incluí as empresas (ou melhor, suas cotações) na seguinte lista Python:

tickers = [            'MSFT',            'AAPL',            'AMZN',            'GOOG',            'FB',            'BRK.B',            'JNJ',            'WMT',            'V',            'PG'            ]

Em seguida, é hora de descobrir como executar o ping da API da nuvem IEX para obter as métricas necessárias para cada empresa.

A API da nuvem IEX retorna objetos JSON em resposta a solicitações HTTP. Como estamos trabalhando com mais de 1 ticker neste tutorial, usaremos a funcionalidade de chamada de API em lote da IEX Cloud, que permite solicitar dados sobre mais de um ticker por vez. O uso de chamadas de API em lote tem dois benefícios:

• Reduz o número de solicitações HTTP que você precisa fazer, o que tornará seu código mais eficiente.
• O preço das chamadas de API em lote é um pouco melhor com a maioria dos provedores de dados.

Aqui está um exemplo de como pode ser a solicitação HTTP, com algumas palavras de espaço reservado nas quais precisaremos personalizar a solicitação:

https://cloud.iexapis.com/stable/stock/market/batch?symbols=TICKERS&types=ENDPOINTS&range=RANGE&token=IEX_API_Key

Neste URL, substituiremos essas variáveis ​​pelos seguintes valores:

• TICKERS será substituído por uma string que contém cada um dos nossos tickers separados por vírgula.
• ENDPOINTS será substituído por uma sequência que contém cada um dos pontos de extremidade da nuvem IEX que queremos atingir, separados por vírgula.
• RANGE será substituído por 1y. Esses pontos de extremidade contêm dados point-in-time e não dados de séries temporais; portanto, esse intervalo pode realmente ser o que você deseja.

Vamos colocar esse URL em uma variável chamada HTTP_request para modificarmos mais tarde:

HTTP_request = 'https://cloud.iexapis.com/stable/stock/market/batch?symbols=TICKERS&types=ENDPOINTS&range=RANGE&token=IEX_API_Key'

Vamos trabalhar com cada uma dessas variáveis, uma por uma, para determinar o URL exato que precisamos atingir.

Para o TICKERS variável, podemos gerar uma variável Python real (e não apenas uma palavra de espaço reservado) com uma simples for ciclo:

#Create an empty string called `ticker_string` that we'll add tickers and commas toticker_string = ''#Loop through every element of `tickers` and add them and a comma to ticker_stringfor ticker in tickers:    ticker_string += ticker    ticker_string += ','    #Drop the last comma from `ticker_string`ticker_string = ticker_string[:-1]

Agora podemos interpolar nossa ticker_string variável para o HTTP_request variável que criamos anteriormente usando uma string-f:

HTTP_request = f'https://cloud.iexapis.com/stable/stock/market/batch?symbols={ticker_string}&types=ENDPOINTS&range=RANGE&token=IEX_API_Key'

Em seguida, precisamos determinar quais pontos de extremidade do IEX Cloud precisamos executar ping.

Algumas investigações rápidas na documentação da nuvem IEX revelam que precisamos apenas do price e stats pontos finais para criar nossa planilha.

Assim, podemos substituir o espaço reservado ENDPOINTS palavra da nossa solicitação HTTP original com a seguinte variável:

endpoints = 'price,stats'

Como fizemos com o nosso ticker_string variável, vamos substituir o endpoints variável para o ticker_string variável:

HTTP_request = f'https://cloud.iexapis.com/stable/stock/market/batch?symbols={ticker_string}&types={endpoints}&range=RANGE&token=IEX_API_Key'

O último espaço reservado que precisamos substituir é RANGE. Não substituiremos por essa variável. Em vez disso, podemos codificar 1y diretamente no caminho da URL como este:

https://cloud.iexapis.com/stable/stock/market/batch?symbols={ticker_string}&types={endpoints}&range=1y&token=IEX_API_Key

Até agora fizemos muito, então vamos recapitular nossa base de código:

import pandas as pdIEX_API_Key = ''#Specify the stock tickers that will be included in our spreadsheettickers = [            'MSFT',            'AAPL',            'AMZN',            'GOOG',            'FB',            'BRK.B',            'JNJ',            'WMT',            'V',            'PG'            ]#Create an empty string called `ticker_string` that we'll add tickers and commas toticker_string = ''#Loop through every element of `tickers` and add them and a comma to ticker_stringfor ticker in tickers:    ticker_string += ticker    ticker_string += ','    #Drop the last comma from `ticker_string`ticker_string = ticker_string[:-1]#Create the endpoint stringsendpoints = 'price,stats'#Interpolate the endpoint strings into the HTTP_request stringHTTP_request = f'https://cloud.iexapis.com/stable/stock/market/batch?symbols={ticker_string}&types={endpoints}&range=1y&token={IEX_API_Key}'

Agora é hora de executar ping na API e salvar seus dados em uma estrutura de dados em nosso aplicativo Python.

Podemos ler objetos JSON com pandas ‘ read_json método. No nosso caso, salvaremos os dados JSON em um pandas DataFrame chamado raw_data, como isso:

raw_data = pd.read_json(HTTP_request)

Vamos aguardar um momento para garantir que os dados foram importados em um bom formato para nosso aplicativo.

Se você estiver trabalhando neste tutorial em um Jupyter Notebook, você pode simplesmente digitar o nome do pandas DataFrame variável na última linha de uma célula de código, e o Jupyter renderizará uma imagem dos dados da seguinte maneira:

Como você pode ver, o pandas DataFrame contém uma coluna para cada cotador de ações e duas linhas: uma para o stats ponto final e um para o price ponto final. Precisamos analisar esse DataFrame para obter as quatro métricas desejadas. Vamos trabalhar as métricas uma a uma nas etapas abaixo.

Métrica 1: Stock Ticker

Esta etapa é muito simples, pois os cotadores de ações estão contidos nas colunas do pandas DataFrame. Podemos acessá-los através do columns atributo do pandas DataFrame como isso:

raw_data.columns

Para acessar as outras métricas em raw_data, criaremos um for loop que percorre cada ticker em raw_data.columns. Em cada iteração do loop, adicionaremos os dados a um novo pandas DataFrame objeto chamado output_data.

Primeiro, precisamos criar output_data, que deve estar vazio pandas DataFrame com quatro colunas. Veja como fazer isso:

output_data = pd.DataFrame(pd.np.empty((0,4)))

Isso cria um vazio pandas DataFrame com 0 linhas e 4 colunas.

Agora que esse objeto foi criado, veja como podemos estruturar esse for ciclo:

for ticker in raw_data.columns:	    #Parse the company's name - not completed yet    company_name = ''        #Parse the company's stock price - not completed yet    stock_price = 0        #Parse the company's dividend yield - not completed yet    dividend_yield = 0            new_column = pd.Series([ticker, company_name, stock_price, dividend_yield])    output_data = output_data.append(new_column, ignore_index = True)

Em seguida, vamos determinar como analisar o company_name variável do raw_data objeto.

Métrica 2: nome da empresa

o company_name variável é a primeira variável precisará ser analisada a partir do raw_data objeto. Como uma rápida recapitulação, eis o que raw_data parece:

o company_name variável é realizada dentro do stats ponto final sob a chave do dicionário companyName. Para analisar esses dados, aponte para raw_data, podemos usar estes índices:

raw_data[ticker]['stats']['companyName']

Incluindo isso em nossa for loop de antes dá o seguinte:

output_data = pd.DataFrame(pd.np.empty((0,4)))for ticker in raw_data.columns:	    #Parse the company's name - not completed yet    company_name = raw_data[ticker]['stats']['companyName']        #Parse the company's stock price - not completed yet    stock_price = 0        #Parse the company's dividend yield - not completed yet    dividend_yield = 0            new_column = pd.Series([ticker, company_name, stock_price, dividend_yield])    output_data = output_data.append(new_column, ignore_index = True)

Vamos passar à análise stock_price.

Metric 3: Preço das Ações

o stock_price variável está contida no price ponto final, que retorna apenas um único valor. Isso significa que não precisamos encadear índices como fizemos com company_name.

Veja como poderíamos analisar stock_price de raw_data:

raw_data[ticker]['price']

Incluindo isso em nossa for loop nos dá:

output_data = pd.DataFrame(pd.np.empty((0,4)))for ticker in raw_data.columns:	    #Parse the company's name - not completed yet    company_name = raw_data[ticker]['stats']['companyName']        #Parse the company's stock price - not completed yet    stock_price = raw_data[ticker]['price']        #Parse the company's dividend yield - not completed yet    dividend_yield = 0            new_column = pd.Series([ticker, company_name, stock_price, dividend_yield])    output_data = output_data.append(new_column, ignore_index = True)

A última métrica que precisamos analisar é dividend_yield.

Métrica 4: Rendimento de dividendos

Gostar company_name, dividend_yield está contido no stats ponto final. É realizada sob a dividendYield chave do dicionário.

Aqui está como poderíamos analisá-lo raw_data:

raw_data[ticker]['stats']['dividendYield']

Adicionando isso ao nosso for loop nos dá:

output_data = pd.DataFrame(pd.np.empty((0,4)))for ticker in raw_data.columns:	    #Parse the company's name - not completed yet    company_name = raw_data[ticker]['stats']['companyName']        #Parse the company's stock price - not completed yet    stock_price = raw_data[ticker]['price']        #Parse the company's dividend yield - not completed yet    dividend_yield = raw_data[ticker]['stats']['dividendYield']            new_column = pd.Series([ticker, company_name, stock_price, dividend_yield])    output_data = output_data.append(new_column, ignore_index = True)

Vamos imprimir nossa output_data objeto para ver como são os dados:

Por enquanto, tudo bem! As próximas duas etapas são para nomear as colunas do pandas DataFrame e para mudar seu índice.

Como nomear as colunas de um DataFrame do Pandas

Podemos atualizar os nomes das colunas dos nossos output_data objeto, criando uma lista de nomes de colunas e atribuindo-a ao output_data.columns atributo, assim:

output_data.columns = ['Ticker', 'Company Name', 'Stock Price', 'Dividend Yield']

Vamos imprimir nossa output_data objeto para ver como são os dados:

Muito melhor! Vamos mudar o índice de output_data Próximo.

Como alterar o índice de um DataFrame do Pandas

O índice de um pandas DataFrame é uma coluna especial que é um pouco semelhante à chave primária de uma tabela de banco de dados SQL. Na nossa output_data objeto, queremos definir o Ticker coluna como o DataFrameíndice de

Veja como podemos fazer isso usando o set_index método:

output_data.set_index('Ticker', inplace=True)

Vamos imprimir nossa output_data objeto para ver como são os dados:

Outra melhoria incremental!

Em seguida, vamos lidar com os dados ausentes no output_data.

Como manipular dados ausentes nos DataFrames do Pandas

Se você olhar atentamente output_data, você notará que existem várias None valores no Dividend Yield coluna:

Estes None os valores simplesmente indicam que a empresa para essa linha atualmente não paga um dividendo. Enquanto None é uma maneira de representar uma ação sem dividendos, é mais comum mostrar uma Dividend Yield do 0.

Felizmente, a correção para isso é bastante direta. o pandas biblioteca inclui uma excelente fillna método que permite substituir valores ausentes em um pandas DataFrame.

Veja como podemos usar o fillna método para substituir o nosso Dividend Yield da coluna None valores com 0:

output_data['Dividend Yield'].fillna(0,inplace=True)

o output_data O objeto parece muito mais limpo agora:

Agora estamos prontos para exportar nosso DataFrame para um documento do Excel! Como uma rápida recapitulação, aqui está o nosso script Python até o momento:

import pandas as pdIEX_API_Key = ''#Specify the stock tickers that will be included in our spreadsheettickers = [            'MSFT',            'AAPL',            'AMZN',            'GOOG',            'FB',            'BRK.B',            'JNJ',            'WMT',            'V',            'PG'            ]#Create an empty string called `ticker_string` that we'll add tickers and commas toticker_string = ''#Loop through every element of `tickers` and add them and a comma to ticker_stringfor ticker in tickers:    ticker_string += ticker    ticker_string += ','    #Drop the last comma from `ticker_string`ticker_string = ticker_string[:-1]#Create the endpoint stringsendpoints = 'price,stats'#Interpolate the endpoint strings into the HTTP_request stringHTTP_request = f'https://cloud.iexapis.com/stable/stock/market/batch?symbols={ticker_string}&types={endpoints}&range=1y&token={IEX_API_Key}'#Create an empty pandas DataFrame to append our parsed values into during our for loopoutput_data = pd.DataFrame(pd.np.empty((0,4)))for ticker in raw_data.columns:	    #Parse the company's name    company_name = raw_data[ticker]['stats']['companyName']        #Parse the company's stock price    stock_price = raw_data[ticker]['price']        #Parse the company's dividend yield    dividend_yield = raw_data[ticker]['stats']['dividendYield']            new_column = pd.Series([ticker, company_name, stock_price, dividend_yield])    output_data = output_data.append(new_column, ignore_index = True)#Change the column names of output_dataoutput_data.columns = ['Ticker', 'Company Name', 'Stock Price', 'Dividend Yield']#Change the index of output_dataoutput_data.set_index('Ticker', inplace=True)#Replace the missing values of the 'Dividend Yield' column with 0output_data['Dividend Yield'].fillna(0,inplace=True)#Print the DataFrameoutput_data

Como exportar um documento com estilo do Excel de um DataFrame do Pandas usando o XlsxWriter

Existem várias maneiras de exportar um xlsx arquivo de um pandas DataFrame.

A maneira mais fácil é usar a função embutida to_excel. Como exemplo, veja como podemos exportar output_data para um arquivo do Excel:

output_data.to_excel('my_excel_document.xlsx)

O problema com essa abordagem é que o arquivo do Excel não tem nenhum formato. A saída é assim:

A falta de formatação neste documento dificulta a interpretação.

Qual é a solução?

Podemos usar o pacote Python XlsxWriter para gerar arquivos do Excel bem formatados. Para começar, adicionaremos a seguinte importação ao início do nosso script Python:

import xlsxwriter

Em seguida, precisamos criar nosso arquivo real do Excel. O pacote XlsxWriter realmente tem uma página de documentação dedicada para saber como trabalhar com pandas DataFrames, que está disponível aqui.

Nosso primeiro passo é chamar o pd.ExcelWriter função e passar o nome desejado de nossa xlsx arquivo como o primeiro argumento e engine='xlsxwriter como o segundo argumento. Vamos atribuir isso a uma variável chamada writer:

writer = pd.ExcelWriter('stock_market_data.xlsx', engine='xlsxwriter')

A partir daí, precisamos chamar o to_excel método em nosso pandas DataFrame. Dessa vez, em vez de passar o nome do arquivo que estamos tentando exportar, passaremos o writer objeto que acabamos de criar:

output_data.to_excel(writer, sheet_name='Sheet1')

Por fim, chamaremos o save método em nosso writer objeto, que salva o xlsx para o nosso diretório de trabalho atual. Quando tudo isso for feito, aqui está a seção do nosso script Python que salva output_data para um arquivo do Excel.

writer = pd.ExcelWriter('stock_market_data.xlsx', engine='xlsxwriter')output_data.to_excel(writer, sheet_name='Sheet1')writer.save()

Todo o código de formatação que incluiremos em nosso xlsx O arquivo precisa estar contido entre a criação do ExcelWriter objeto e o writer.save() declaração.

Como estilizar um xlsx Arquivo criado com Python

Na verdade, é mais difícil do que você imagina criar um arquivo do Excel usando Python.

Isso ocorre parcialmente devido a algumas das limitações do pacote XlsxWriter. Sua documentação declara:

O XlsxWriter e o Pandas fornecem muito pouco suporte para formatar os dados de saída de um quadro de dados, além da formatação padrão, como as células de cabeçalho e índice e quaisquer células que contenham datas ou datas. Ademais, não é possível formatar células que já tenham um formato padrão aplicado.

Se você precisar de formatação muito controlada da saída do quadro de dados, provavelmente será melhor usar o Xlsxwriter diretamente com dados brutos retirados do Pandas. No entanto, algumas opções de formatação estão disponíveis.

Na minha experiência, a maneira mais flexível de estilizar células em um xlsx O arquivo criado pelo XlsxWriter deve usar a formatação condicional que só aplica estilo quando uma célula não é igual a None.

Isso tem três vantagens:

1. Ele fornece mais flexibilidade de estilo do que as opções de formatação normais disponíveis no XlsxWriter.
2. Você não precisa percorrer manualmente cada ponto de dados e importá-los para o writer objeto um por um.
3. Permite ver facilmente quando None valores fizeram o seu caminho em seu finalizado xlsx arquivos, uma vez que faltam a formatação necessária.

Para aplicar estilo usando formatação condicional, primeiro precisamos criar alguns modelos de estilo. Especificamente, precisaremos de quatro modelos:

• 1 header_template que será aplicado aos nomes das colunas na parte superior da planilha
• 1 string_template que será aplicado ao Ticker e Company Name colunas
• 1 dollar_template que será aplicado ao Stock Price coluna
• 1 percent_template que será aplicado ao Dividend Yield coluna

Cada um desses modelos de formato precisa ser adicionado ao writer objeto nos dicionários que se assemelham à sintaxe CSS. Aqui está o que eu quero dizer:

header_template = writer.book.add_format(        {            'font_color': '#ffffff',            'bg_color': '#135485',            'border': 1        }    )string_template = writer.book.add_format(        {            'bg_color': '#DADADA',            'border': 1        }    )dollar_template = writer.book.add_format(        {            'num_format':'$0.00',            'bg_color': '#DADADA',            'border': 1        }    )percent_template = writer.book.add_format(        {            'num_format':'0.0%',            'bg_color': '#DADADA',            'border': 1        }    )

Para aplicar esses formatos a células específicas em nossa xlsx arquivo, precisamos chamar o pacote conditional_format método em writer.sheets['Stock Market Data']. Aqui está um exemplo:

writer.sheets['Stock Market Data'].conditional_format('A2:B11',                              {                                'type':     'cell',                                'criteria': '<>',                                'value':    '"None"',                                'format':   string_template                                }                            )

Se generalizarmos essa formatação para os outros três formatos que estamos aplicando, aqui está a seção de formatação do nosso script Python:

writer = pd.ExcelWriter('stock_market_data.xlsx', engine='xlsxwriter')output_data.to_excel(writer, sheet_name='Stock Market Data')header_template = writer.book.add_format(        {            'font_color': '#ffffff',            'bg_color': '#135485',            'border': 1        }    )string_template = writer.book.add_format(        {            'bg_color': '#DADADA',            'border': 1        }    )dollar_template = writer.book.add_format(        {            'num_format':'$0.00',            'bg_color': '#DADADA',            'border': 1        }    )percent_template = writer.book.add_format(        {            'num_format':'0.0%',            'bg_color': '#DADADA',            'border': 1        }    )#Format the header of the spreadsheetwriter.sheets['Stock Market Data'].conditional_format('A1:D1',                              {                                'type':     'cell',                                'criteria': '<>',                                'value':    '"None"',                                'format':   header_template                                }                            )#Format the 'Ticker' and 'Company Name' columnswriter.sheets['Stock Market Data'].conditional_format('A2:B11',                              {                                'type':     'cell',                                'criteria': '<>',                                'value':    '"None"',                                'format':   string_template                                }                            )#Format the 'Stock Price' columnwriter.sheets['Stock Market Data'].conditional_format('C2:C11',                              {                                'type':     'cell',                                'criteria': '<>',                                'value':    '"None"',                                'format':   dollar_template                                }                            )#Format the 'Dividend Yield' columnwriter.sheets['Stock Market Data'].conditional_format('D2:D11',                              {                                'type':     'cell',                                'criteria': '<>',                                'value':    '"None"',                                'format':   percent_template                                }                            )writer.save()

Vamos dar uma olhada no nosso documento do Excel para ver como está:

Por enquanto, tudo bem! A última melhoria incremental que podemos fazer neste documento é tornar suas colunas um pouco mais amplas.

Podemos especificar larguras de coluna chamando o set_column método em writer.sheets['Stock Market Data'].

Aqui está o que adicionaremos ao nosso script Python para fazer isso:

#Specify all column widthswriter.sheets['Stock Market Data'].set_column('B:B', 32)writer.sheets['Stock Market Data'].set_column('C:C', 18)writer.sheets['Stock Market Data'].set_column('D:D', 20)

Aqui está a versão final da planilha:

Voila! Estamos prontos para ir! Você pode acessar a versão final deste script Python no GitHub aqui. O arquivo é nomeado stock_market_data.py.

Etapa 3: configurar uma máquina virtual do AWS EC2 para executar seu script Python

Seu script Python está finalizado e pronto para ser executado.

No entanto, não queremos simplesmente executar isso em nossa máquina local em uma base ad hoc.

Em vez disso, vamos configurar uma máquina virtual usando Elastic Compute Cloud da Amazon Web Services (EC2).

Você precisará criar uma conta da AWS primeiro se ainda não tiver uma. Para fazer isso, navegue até esse 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, você precisará criar uma instância do EC2. Este é simplesmente um servidor virtual para executar código na infraestrutura da AWS.

As instâncias do EC2 vêm em vários sistemas operacionais e tamanhos, variando de servidores muito pequenos que se qualificam ao nível gratuito da AWS a servidores muito grandes, capazes de executar aplicativos complexos.

Usaremos o menor servidor da AWS para executar o script Python que escrevemos neste artigo. Para começar, navegue até o EC2 no console de gerenciamento da AWS. Depois de chegar ao EC2, clique em Launch Instance:

Isso levará você a uma tela que contém todos os tipos de instância disponíveis no AWS EC2. Qualquer máquina qualificada para o nível gratuito da AWS será suficiente.

Eu escolhi o Amazon Linux 2 AMI (HVM):

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:

Depois de selecionar uma máquina qualificada de nível gratuito, clique em 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.

Depois de selecionar ou criar um par de chaves para esta instância do EC2 e clique no botão de opção para I acknowledge that I have access to the selected private key file (data-feeds.pem), and that without this file, I won't be able to log into my instance, você pode clicar Launch Instances para prosseguir.

Sua instância agora começará a ser iniciada. Pode levar algum tempo até que essas instâncias sejam inicializadas, mas uma vez prontas, as Instance State mostrará como running no seu painel do EC2.

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 stock_market_data.py na instância do EC2.

Tentando correr stock_market_data.py nesse ponto, na verdade, resultará em um erro porque a instância do EC2 não vem com os pacotes Python necessários.

Para corrigir isso, 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-pippip3 install pandaspip3 install xlsxwriter

Feito isso, você pode fazer o SSH na instância do EC2 e executar o script Python na linha de comando com a seguinte instrução:

python3 stock_market_data.py

Etapa 4: criar um bucket do AWS S3 para manter o script Python finalizado

Com o trabalho que concluímos até agora, nosso script Python pode ser executado dentro de nossa instância do EC2.

O problema disso é que o xlsx O arquivo será salvo no servidor virtual da AWS.

Não está acessível a ninguém, exceto a nós nesse servidor, o que limita sua utilidade.

Para corrigir isso, vamos criar um bucket público no AWS S3, onde podemos salvar o xlsx Arquivo. Qualquer pessoa que possua o URL correto poderá fazer o download deste arquivo assim que essa alteração for feita.

Para começar, navegue até o AWS S3 de dentro do AWS Management Console. Clique Create bucket no canto superior direito:

Na próxima tela, você precisará escolher um nome para seu bucket e uma região da AWS para o host a ser hospedado. O nome do bucket deve ser exclusivo e não pode conter espaços ou letras maiúsculas. A região não importa muito para os fins deste tutorial, portanto, usarei a região padrão de US East (Ohio) us-east-2).

Você precisará alterar as configurações de Acesso público na próxima seção para corresponder a esta configuração:

Clique Create bucket para criar seu bucket e concluir esta etapa deste tutorial!

Etapa 5: Modifique seu script Python para enviar o arquivo xlsx para o AWS S3

Nosso balde AWS S3 está pronto para realizar nossa finalização xlsx documento. Agora faremos uma pequena alteração em nosso stock_market_data.py arquivo para enviar o documento finalizado para o nosso bucket S3.

Nós precisaremos usar o boto3 pacote para fazer isso. boto3 é o AWS Software Development Kit (SDK) para Python, permitindo que os desenvolvedores de Python escrevam software que se conecta aos serviços da AWS. Para começar, você precisará instalar boto3 na sua máquina virtual EC2. Execute a seguinte instrução de linha de comando para fazer isso:

pip3 install boto3

Você também precisará importar a biblioteca para stock_market_data.py adicionando a seguinte declaração à parte superior do script Python.

import boto3

Nós precisaremos adicionar algumas linhas de código no final de stock_market_data.py para enviar o documento final para o AWS S3.

s3 = boto3.resource('s3')s3.meta.client.upload_file('stock_market_data.xlsx', 'my-S3-bucket', 'stock_market_data.xlsx', ExtraArgs={'ACL':'public-read'})

A primeira linha deste código, s3 = boto3.resource('s3'), permite que nosso script Python se conecte ao Amazon Web Services.

A segunda linha de código chama um método de boto3 que realmente carrega nosso arquivo para o S3. São necessários quatro argumentos:

• stock_market_data.xlsx – o nome do arquivo em nossa máquina local.
• my-S3-bucket – o nome do bucket S3 para o qual estamos carregando nosso arquivo.
• stock_market_data.xlsx – o nome desejado do arquivo no bucket do S3. Na maioria dos casos, isso terá o mesmo valor que o primeiro argumento passado para esse método.
• ExtraArgs={'ACL':'public-read'} – esse é um argumento opcional que informa à AWS para tornar o arquivo carregado legível ao público.

Etapa 6: agendar seu script Python para executar periodicamente usando Cron

Até agora, concluímos o seguinte:

• Criamos nosso script Python
• Criamos uma instância do EC2 e implantamos nosso código lá
• Criou um bucket S3 onde podemos empurrar a final xlsx documento
• Modificado o script Python original para fazer upload do arquivo finalizado stock_market_data.xlsx arquivo em um bucket do AWS S3

A única etapa que resta é agendar o script Python para ser executado periodicamente.

Podemos fazer isso usando um utilitário de linha de comando chamado cron. Para começar, precisaremos criar um cron expressão que informa ao utilitário quando executar o código. o guru do crontab site é um excelente recurso para isso.

Veja como você pode usar o crontab guru para obter cron expressão que significa every day at noon:

Agora precisamos instruir nossas instâncias do EC2 cron daemon para executar stock_market_data.py a essa hora todos os dias.

Para fazer isso, primeiro criaremos um novo arquivo em nossa instância do EC2 chamado stock_market_data.cron.

Abra esse arquivo e digite nossa expressão cron seguida pela instrução que deve ser executada na linha de comando no horário especificado.

Nossa declaração de linha de comando é python3 stock_market_data.py, então aqui está o que deve estar contido em stock_market_data.cron:

00 12 * * * python3 stock_market_data.py

Se você executar um ls comando na sua instância do EC2, agora você deve ver dois arquivos:

stock_market_data.py	stock_market_data.cron

A última etapa deste tutorial é carregar stock_market_data.cron no crontab. Você pode pensar no crontab como um arquivo que contém comandos e instruções para o cron daemon para executar. Em outras palavras, o crontab contém lotes de cron empregos.

Primeiro, vamos ver o que está em nossa crontab. Deve estar vazio, pois não colocamos nada nele! Você pode ver o conteúdo do seu crontab com o seguinte comando:

crontab -l

Carregar stock_market_data.cron no crontab, execute a seguinte instrução na linha de comandos:

crontab stock_market_data.cron

Agora, quando você corre crontab -l, Você deveria ver:

00 12 * * * python3 stock_market_data.py

Nosso stock_market_data.py Agora, o script será executado diariamente ao meio-dia em nossa máquina virtual AWS EC2!

Pensamentos finais

Neste artigo, você aprendeu como criar planilhas de dados financeiros do Excel com atualização automática usando Python, IEX Cloud e Amazon Web Services.

Aqui estão as etapas específicas que abordamos neste tutorial:

• Como criar uma conta no IEX Cloud
• Como escrever um script Python que gera belos documentos do Excel usando pandas e XlsxWriter
• Como iniciar uma instância do AWS EC2 e implantar código nela
• Como criar um bucket do AWS S3
• Como enviar arquivos para um bucket do AWS S3 de dentro de um script Python
• Como agendar código para execução usando o cron utilitário de software

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