-
Notifications
You must be signed in to change notification settings - Fork 5
/
deploy.qmd
200 lines (132 loc) · 9 KB
/
deploy.qmd
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
```{r, echo = FALSE}
knitr::opts_chunk$set(
fig.align = "center"
)
```
# Deploy {#sec-deploy}
Neste capítulo (e neste livro como um todo), falaremos de deploy apenas no contexto do serviço [shinyapps.io](https://shinyapps.io) e da configuração de um Shiny Server.
Não falaremos neste livro sobre a utilização de computação em nuvem pois existem muitos serviços disponíveis (AWS, Google Cloud Plataform, Azure etc) e é um tema em constante atualização.
## ShinyApps.io {#sec-deploy-shinyapps}
O [ShinyApps.io](https://www.shinyapps.io/) é um serviço da [RStudio](https://rstudio.com/) para hospedagem de aplicativos Shiny.
A conta gratuita permite até 5 aplicações simultâneas e 25 horas mensais de uso (um aplicativo utilizado por 1 hora consome 1 hora do seu plano, 2 aplicativos utilizados simultaneamente por 1 hora consomem 2 horas do seu plano). As contas pagas, além de mais horas, fornecem outras vantagens, como suporte personalizado e autenticação.
Criada uma conta, você deve conectá-la com o RStudio. Feito isso, você conseguirá fazer o deploy do seu app com alguns cliques. A seguir, mostramos o passo a passo para conectar a sua conta e para fazer o deploy do seu app.
### Conectando a sua conta com o RStudio
Primeiro, crie uma conta no serviço site [shinyapps.io](https://www.shinyapps.io/).
Faço o login na sua conta e, no menu lateral, acesse Account > Tokens.
```{r, echo = FALSE, out.width="30%"}
knitr::include_graphics("img/shinyapps-sidebar.png")
```
Na página de tokens, clique no botão "Add Token" para criar um novo token. No token criado, clique no botão "Show".
Na caixa de diálogo aberta, clique no botão "Copy to clipboard" ou clique no botão "Show secret" e copie o código apresentado à esquerda dos botões.
```{r, eval = FALSE}
# O código que você deve copiar é similar a este
rsconnect::setAccountInfo(name = 'sua_conta',
token = 'seu_token',
secret = 'secret_do_token>')
```
Abra o seu RStudio e acesse Tools > Global Options... > Publishing.
Na seção "Publishing sections", clique no botão "Connect".
```{r, echo = FALSE, out.width="70%"}
knitr::include_graphics("img/shinyapps-menu-publishing.png")
```
Selecione a opção "ShinyApps.io." e, na tela seguinte, cole o código copiado no site. Clique em Connect Account e pronto! Seu RStudio estará conectado com a sua conta do ShinyApps.io. Você só precisa fazer isso uma vez por conta ou computador.
```{r, echo = FALSE, out.width="70%"}
knitr::include_graphics("img/shinyapps-connect.png")
```
### Subindo o seu app
Com a conta conectada, para subir um app para o servidor do shinyapps.io basta abrir o script do seu app e clicar no botão "Publish".
```{r, echo = FALSE, out.width="70%"}
knitr::include_graphics("img/shinyapps-botao-publish.png")
```
Na caixa de diálogo, selecione à esquerda o código do seu app e todos os outros arquivos dos quais ele depende, como bases de dados e a pasta `www`. Em seguida, escolha um nome para o seu aplicativo (esse nome fará parte do link) e clique em "Publish".
```{r, echo = FALSE, out.width="70%"}
knitr::include_graphics("img/shinyapps-publishing.png")
```
O processo de deploy pode levar alguns minutos, a depender das dependências do seu app e tamanho dos arquivos que você subir. Quando o processo terminar, você receberá uma URL para acessar o aplicativo.
Caso o seu app não abra devido a algum erro, você pode acessar os logs de utilização para ter uma dica do que aconteceu. Para isso, no dashboard do ShinyApps.io, acesse Applications > All, no meu lateral. Em seguida, clique no app que você gostaria de investigar. Por fim, acesse a opção "Logs".
```{r, echo = FALSE, out.width="100%"}
knitr::include_graphics("img/shinyapps-log.png")
```
## Autenticação
Quando subimos um app para o shinyapps.io, nosso app passa a ficar disponível em uma URL pública (i.e. qualquer pessoa pode acessar.). O serviço permite autenticação apenas a partir da conta Standard, cujo alto custo mensal pode ser um impedimento.
Nesta seção abordaremos algumas soluções gratuitas^[Ou gratuitas até uma certa quantidade de uso.] para criar uma etapa de autenticação no acesso ao seu app. Começaremos com o pacote `auth0`.
### Autenticação com o pacote `auth0`
O `{auth0}` é um pacote desenvolvido pela equipe da Curso-R que permite a implementação de um esquema de autenticação no Shiny usando o serviço [Auth0](https://auth0.com).
Você pode instalar o pacote diretamente do CRAN:
```{r, eval = FALSE}
install.packages("auth0")
```
A seguir, apresentaremos um passo a passo para criar um app com autenticação usando o `auth0`. Para mais informações sobre o pacote, [clique aqui](https://github.com/curso-r/auth0).
#### Passo 1: criar uma conta no serviço Auth0 {-}
- Entre no site [auth0.com](https://auth0.com).
- Clique em "Sign Up".
- Você pode criar uma conta a partir de um nome de usário e senha ou a partir de uma conta do GitHub ou do Google.
#### Passo 2: crie uma aplicação Auth0 {-}
- Faça login no no site [auth0.com](https://auth0.com) usando a criada no passo 1. Você deverá ver uma página como a abaixo:
```{r, echo=FALSE}
knitr::include_graphics("img/auth0_tela_inicial.png")
```
- No menu à esquerda, clique em Applications > applications e então no botão "Create Application".
- Dê um nome para o seu app.
- Selecione "Regular Web Applications" e clique em "Create".
#### Passo 3: configure a sua aplicação {-}
- Na página da sua aplicação, clique em "Settings".
```{r, echo=FALSE}
knitr::include_graphics("img/auth0_app_settings.png")
```
- Para usar o `auth0` quando estiver rodando o seu app localmente:
- Adicione `http://localhost:8080` aos campos "Allowed Callback URLs", "Allowed Logout URLs" e "Allowed Web Origins".
- Você pode mudar a porta `8080` para qualquer outra que estiver utilizando.
- Para usar o `auth0` em seu app hospedado no shinyapps.io:
- Adicione a URL completa do seu app (i.e., `https://suaconta.shinyapps.io/seu_app`) aos campos "Allowed Callback URLs" e "Allowed Logout URLs".
- Adicione a parte inicial da URL do seu app (i.e., `https://suaconta.shinyapps.io`) ao campo "Allowed Web Origins".
- Para usar o `auth0` em seu app hospedado em um servidor remoto qualquer:
- Adicione a URL do seu app aos campos "Allowed Callback URLs", "Allowed Logout URLs" e "Allowed Web Origins".
- Se o seu app estiver dentro de uma pasta, isto é, se a URL dele for algo como `https://meuservidor.com/meuapp`, no campo "Allowed Web Origins" acrescente apenas `https://meuservidor.com`.
- Clique em `Save Changes`.
#### Passo 4: configurando o seu Shiny app {-}
- Crie um arquivo de configuração para o seu app rodando a função `auth0::use_auth0()`
- Esse arquivo deve estar na mesma pasta que o script do seu app.
- Você pode escolher o diretório onde o arquivo será criado usando o argumento `path`. Para mais detalhes, veja a documentão da função.
```{r, eval = FALSE}
auth0::use_auth0()
```
- O arquivo `_auth0.yml` gerado deve conter o seguinte:
```{yml}
name: myApp
remote_url: ""
auth0_config:
api_url: !expr paste0("https://", Sys.getenv("AUTH0_USER"), ".auth0.com")
credentials:
key: !expr Sys.getenv("AUTH0_KEY")
secret: !expr Sys.getenv("AUTH0_SECRET")
```
- Na linha `remote_url: ""`, coloque a URL do seu app dentro das aspas.
- Rode `usethis::edit_r_environ(scope = "project")` e acrescente as seguintes variáveis de ambiente^[Saiba mais sobre variáveis de ambiente [aqui](https://csgillespie.github.io/efficientR/set-up.html#renviron)]:
```{yml}
AUTH0_USER=...
AUTH0_KEY=...
AUTH0_SECRET=...
```
- Substitua os `...` pelos valores encontrados na opção `Settings` da sua aplicação no Auth0, conforme a imagem abaixo:
```{r, echo=FALSE}
knitr::include_graphics("img/auth0_app_variaveis.png")
```
- Salve o arquivo e reinicie a sua sessão.
- No seu aplicativo Shiny, substitua `shiny::shinyApp(ui, server))` pelo código abaixo.
```{r, eval = FALSE}
auth0::shinyAppAuth0(ui, server, options = list(port = 8080))
```
- Para rodar localmente, a porta `8080` em `options = list(port = 8080)` deve ser a mesma definida em `http://localhost:8080` no Passo 3.
- Para o RStudio continuar reconhecendo o seu script como um Shiny app, você deve nomeá-lo `app.R`. Caso contrário, você não terá acesso aos botões "Run App" ou "Publish".
#### Passo 5: rode o seu app {-}
- Rode o seu app.
- Se toda a configuração tiver sido feita corretamente, você será redirecionado para uma página de login antes de ter acesso ao seu app.
#### Passo 6 (opcional): configurando o acesso {-}
- Para desabilitar "Sign ups":
- No Auth0, acesse pelo menu à esquerda Authentication > Database e clique em "Username-Password-Authentication".
- Habilite a opção "Disable Sign Ups" se você não quiser que qualquer pessoa consiga se inscrever para usar seu app.
- Para criar logins:
- No Auth0, acesse pelo menu à esquerda User Management > Users e clique em "Create User".
- Preencha os campos "Email" e "Password" e clique em "Create".
## Configurando um Shiny Server