---
# System prepended metadata

title: AWS guide

---

# AWS guide

## RStudio Server na VM

- Acesse: https://www.louisaslett.com/RStudio_AMI/
- Clique no link referente à South America, São Paulo (Ou no mesmo local onde os dados são salvos)

Isso irá abrir uma página para criação de uma nova instância EC2 pré configurada para utilizar o RStudio server. 

- Defina o nome da máquina
- Escolha as configurações de processador e memória (Recomendado: r5ad.large ou c5ad.2xlarge)
- Em par de chaves, escolha ou crie um novo para se conectar via SSH no futuro.
- Em configurações de rede, deixe marcada a opção de tráfego por SSH.
- Marque também as opções de acesso HTTP e HTTPS
- Por fim, clique em Executar instância. 

O último passo acima gera uma página com o aviso "Execução da instância iniciada com êxito (<link>)". Clique no link para ir ao console de gerenciamento da instância. Aguarde sair do status "Inicializando" antes de prosseguir. 

- Clique no id da instância, isto irá levar à uma aba com mais informações. 
- Copie o Endereço IPv4 público e cole no navegador. 
- Faça o login
    - Usuário: rstudio
    - Senha: ID da instância
- Siga os passos apresentados no Welcome.R para definir uma nova senha 
- Lembre-se de desligar (Interromper) a máquina quando terminar.

## Shiny server 

O procedimento acima também instala o shiny server na VM. Para utilização basta salvar os aplicativos shiny no diretório `Home/ShinyApps` e acessá-los como o seguiente exemplo: 

- http://177.71.194.171/shiny/rstudio/sample-apps/hello/

Onde `sample-apps/hello` está em `Home/ShinyApps`

### Conexão com dados do S3 

Biblioteca: aws.s3

Configure o acesso usando as chaves, conforme o código abaixo. 

```
Sys.setenv("AWS_ACCESS_KEY_ID" = "mykey",
           "AWS_SECRET_ACCESS_KEY" =  mysecretkey")
```

Para gerar estas chaves vá em Security credentials> Criar chave de acesso.

#### Leitura e Escrita na S3 pela VM usando o R

As principais funções são ```s3read_using``` e ```s3write_using``` 

**Exemplo**

```
library(aws.s3)
library(tidyverse)

Sys.setenv("AWS_ACCESS_KEY_ID" = "AKIAXF3SHUYFOEEP5YXQ",
           "AWS_SECRET_ACCESS_KEY" = "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")

bucket_exists(
  bucket = "s3://caio1910/", 
  region = "sa-east-1"
)

df = s3read_using(FUN=read.csv, 
                  object="datasets/iris/Iris.csv",
                  sep = ",",
                  header=T, 
                  bucket = "s3://caio1910/", 
                  opts = list(region = "sa-east-1"))
                  
df %>% head()
```

#### Intalação do Python e Pyspark

- Instale a versão mais recente do python ```sudo apt install python3```
- Siga os seguintes passos para configurar um ambiente virtual: https://support.posit.co/hc/en-us/articles/360023654474-Installing-and-Configuring-Python-with-RStudio
- Antes de instalar qualquer pacote é preciso ativar o enviroment: ```source my_env/bin/activate```
- Vá ao diretório do projeto usando ```cd``` e rode o comando do intem acima no terminal.
- Instale o pyspark: ```pip install pyspark```
- Teste executando:

```
from pyspark.sql import SparkSession

spark = SparkSession.builder.config("spark.driver.memory", "5g").getOrCreate()

spark.sparkContext._conf.getAll()
```

#### Leitura e Escrita na S3 pela VM usando o Pyspark

https://davidlindelof.com/reading-s3-data-from-a-local-pyspark-session/

# Glue

## Data Catalog 

- Copie a URI do S3 da pasta que deseja catalogar (Obs: Deixe apenas arquivos da mesma tabela na pasta)
- Acesse o AWS Glue pelo buscador > Crawlers
- Create crawler
- Especifique o nome e a descrição deste crawler
- Clique em add a data source
- Cole a URI do S3 em s3 path
- Clique em add an S3 data source
- Next
- Crie uma nova IAM role
- Next
- Em Add database crie a base de dados que irá conter as tabelas do S3
- Volte para a pagina anterior, recarregue o seletor e selecione a base de dados que criou. 
- Defina a frequência que o crawler irá rodar para fezer o mapeamento das tabelas. 
- Next
- Confira as especificações e clique em Create crawler.
- Clique em Run crawler e aguarde ele identificar as tabelas. 
- Vá para Databases e clique na base de dados que você criou para visualizá-las. 

Pronto, agora o Glue já catalogou os dados disponíveis no S3 e os deixou mapeados para que outras ferramentas possam acessar. 



# Athena

- Acesse o Athena pelo buscador > query editor
- Selecionando o Database você verá todas as tabelas catalogadas pelo data catalog.
- Você verá a mensagem "Before you run your first query, you need to set up a query result location in Amazon S3."
- Clique em Edit settings.
- Informe o caminho onde os resultados das queries serão salvos. (Obs: devem estar na mesma região)
- Crie a query desejada
- Ao salvar a query os resultados também estarão salvos no diretório indicado anteriormente e você também pode baixá-los diretamente. 


## Conexão da VM ao Athena 

Acesse a VM via SSH, para isso siga os passos: 

- Clique em "Conectar" no canto superior direito. Na aba Cliente SSH você verá um exemplo com o comando usado na conexão, rode no terminal da máquina local substituindo ubuntu por rstudio, nome padrão do usuário da VM. 
- Insira a senha do usuário rstudio para se conectar. 

Siga os passos abaixo para habilitar a conexão com o Athena. Mas atenção, pode ser necessário esperar a VM finalizar alguns processos de atualização, é possível acompanhar a evolução com o ```htop```, prossiga quando nada estiver rodando.

Caso não queira esperar pelas atualizações, execute: 

```sudo dpkg-reconfigure -plow unattended-upgrades```

e escolha a opção de não realizar o download automático. Em seguida reinicie a VM e se reconecte. Neste caso o ```htop``` deve indicar que não há nada mais sendo executado. Prossiga com os passos abaixo rodando uma linha de cada vez para instalar o rJava

```
sudo apt-get install -y default-jre
sudo apt-get install -y default-jdk
sudo R CMD javareconf
```

Abra uma seção do R pelo terminal e instale os pacotes necessários, para isso execute:

```
R
install.packages("rJava")
install.packages("RJDBC")
install.packages("AWR.Athena")
install.packages("DBI")
```
Agora se conect na VM pelo Rstudio server para executar os demais passos. 

- Carregue os pacotes: rJava, RJDBC, tidyverse, AWR.Athena e DBI.
- Configure o acesso usando as chaves, conforme o código abaixo. 

```
Sys.setenv("AWS_ACCESS_KEY_ID" = "mykey",
           "AWS_SECRET_ACCESS_KEY" =  mysecretkey")
```

- Crie uma conexão com o seguinte comando: 

```
con <- dbConnect(AWR.Athena::Athena(), 
                 region='REGIAO DOS DADOS', 
                 S3OutputLocation='CAMINHO ESPECIFICADO NO ATHENA PARA SALVAR AS QUERIES', 
                 Schema='default')
```

- Você pode ver as tabelas disponíveis com o comando ```dbListTables(con)```
- Execute suas queries com a função ```dbGetQuery(con, "QUERY")```

#### Exemplo 

```
library(tidyverse)
library(rJava)
library(RJDBC)
library(AWR.Athena)
library(DBI)

Sys.setenv("AWS_ACCESS_KEY_ID" = "AKIAXF3SHUYFOEEP5YXQ",
           "AWS_SECRET_ACCESS_KEY" = "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")


con <- dbConnect(AWR.Athena::Athena(), region='sa-east-1', S3OutputLocation='s3://caio1910/queries/', Schema='default')
dbListTables(con)

dbGetQuery(con, "SELECT * FROM datasets.iris limit 10")
```