# 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:

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")