One place for hosting & domains

      Aplicativo

      Como configurar um aplicativo Node.js para produção no Ubuntu 20.04


      Introdução

      O Node.js é um ambiente de execução de código aberto do JavaScript para construção de aplicativos de rede e do servidor. A plataforma executa nos sistemas operacionais Linux, macOS, FreeBSD e Windows. Embora você possa executar aplicativos Node.js na linha de comando, este tutorial se concentrará em executá-los como um serviço. Isso significa que eles irão reiniciar após reinicialização ou falha, sendo seguros para utilização em um ambiente de produção.

      Neste tutorial, você irá configurar um ambiente Node.js pronto para produção em um único servidor Ubuntu 20.04. Este servidor executará um aplicativo Node.js gerenciado pelo PM2 e fornecerá aos usuários acesso seguro ao aplicativo através de um proxy reverso Nginx. O servidor Nginx oferecerá HTTPS usando um certificado gratuito fornecido pelo Let’s Encrypt.

      Pré-requisitos

      Este guia supõe que você tenha o seguinte:

      Quando você tiver cumprido com os pré-requisitos, você terá um servidor atendendo a página do espaço reservado padrão do seu domínio em https://example.com/.

      Passo 1 — Instalando o Node.js

      Vamos começar instalando a versão mais recente do Node.js com LTS, ou Long-Term Support (Suporte de longo prazo), usando os arquivos do pacote NodeSource.

      Primeiramente, instale o NodeSource PPA para ter acesso ao seu conteúdo. Certifique-se de que você esteja em seu diretório base, e use o curl para recuperar o script de instalação para a versão LTS mais recente do Node.js dos seus arquivos.

      • cd ~
      • curl -sL https://deb.nodesource.com/setup_14.x -o nodesource_setup.sh

      É possível verificar o conteúdo deste script com o nano ou seu editor de texto preferido:

      Quando terminar de inspecionar o script, execute-o sob o sudo:

      • sudo bash nodesource_setup.sh

      O PPA será adicionado à sua configuração e seu cache de pacotes local será atualizado automaticamente. Após executar o script de configuração do Nodesource, você pode instalar o pacote do Node.js:

      Para verificar qual versão do Node.js você tem instalada após esses passos iniciais, digite:

      Output

      v14.4.0

      Nota: ao instalar a partir do NodeSource com PPA, o arquivo executável Node.js é chamado de nodejs e não node.

      O pacote nodejs contém o binário do nodejs assim como o npm, um gerenciador de pacotes para módulos Node, então não é necessário instalar o npm separadamente.

      O npm usa um arquivo de configuração no seu diretório home para controlar as atualizações. Ele será criado na primeira vez que você executar o npm. Execute este comando para verificar se o npm está instalado e crie o arquivo de configuração:

      Output

      6.14.5

      Para que alguns pacotes npm possam funcionar (os que requerem compilar o código da fonte, por exemplo), será necessário instalar o pacote build-essential:

      • sudo apt install build-essential

      Agora, você tem as ferramentas necessárias para trabalhar com os pacotes npm que requerem a compilação do código da fonte.

      Com o ambiente de execução Node.js instalado, vamos seguir em frente para escrever um aplicativo Node.js.

      Passo 2 — Criando um aplicativo Node.js

      Vamos escrever um aplicativo Hello World que retorna “Hello World” a qualquer pedido de HTTP. Este aplicativo exemplo ajudará você a configurar o Node.js. Você pode substituí-lo pelo seu próprio aplicativo — certifique-se apenas de que você modifique seu aplicativo para escutar os endereços IP e portas apropriadas.

      Primeiramente, vamos criar um aplicativo exemplo chamado hello.js:

      Insira o seguinte código no arquivo:

      ~/hello.js

      const http = require('http');
      
      const hostname="localhost";
      const port = 3000;
      
      const server = http.createServer((req, res) => {
        res.statusCode = 200;
        res.setHeader('Content-Type', 'text/plain');
        res.end('Hello World!n');
      });
      
      server.listen(port, hostname, () => {
        console.log(`Server running at http://${hostname}:${port}/`);
      });
      

      Salve o arquivo e saia do editor.

      Este aplicativo Node.js escuta no endereço especificado (localhost) e porta (3000) e retorna “Hello World!” com um código de sucesso HTTP 200. Uma vez que estamos escutando no localhost, clientes remotos não poderão se conectar ao nosso aplicativo.

      Para testar seu aplicativo, digite:

      Você receberá o seguinte resultado:

      Output

      Server running at http://localhost:3000/

      Nota: executar um aplicativo Node.js dessa maneira irá bloquear comandos adicionais até que o aplicativo seja encerrado pressionando-se CTRL+C.

      Para testar o aplicativo, abra outra sessão de terminal no seu servidor e conecte-se ao localhost com o curl:

      • curl http://localhost:3000

      Caso obtenha o seguinte resultado, o aplicativo está funcionando corretamente e escutando no endereço e porta corretos:

      Output

      Hello World!

      Caso não obtenha o resultado esperado, certifique-se de que seu aplicativo Node.js esteja funcionando e configurado para escutar no endereço e porta apropriados.

      Assim que tiver certeza certeza de que ele está funcionando, encerre o aplicativo (se você ainda não o tiver feito) pressionando CTRL+C.

      Passo 3 — Instalando o PM2

      Em seguida, vamos instalar o PM2, um gerenciador de processos para aplicativos Node.js. O PM2 torna possível forçar os aplicativos a executarem como daemon para que eles executem em segundo plano como um serviço.

      Utilize o npm para instalar a última versão do PM2 no seu servidor:

      • sudo npm install pm2@latest -g

      A opção -g faz com que o npm instale o módulo globally, para que ele esteja disponível em todo o sistema.

      Vamos usar primeiro o comando pm2 start para executar seu aplicativo, hello.js, em segundo plano:

      Isso também adiciona seu aplicativo na lista de processos do PM2, que é produzida toda vez que você inicia um aplicativo:

      Output

      ... [PM2] Spawning PM2 daemon with pm2_home=/home/sammy/.pm2 [PM2] PM2 Successfully daemonized [PM2] Starting /home/sammy/hello.js in fork_mode (1 instance) [PM2] Done. ┌────┬────────────────────┬──────────┬──────┬───────────┬──────────┬──────────┐ │ id │ name │ mode │ ↺ │ status │ cpu │ memory │ ├────┼────────────────────┼──────────┼──────┼───────────┼──────────┼──────────┤ │ 0 │ hello │ fork │ 0 │ online │ 0% │ 25.2mb │ └────┴────────────────────┴──────────┴──────┴───────────┴──────────┴──────────┘

      Assim como indicado acima, o PM2 atribui automaticamente um App name (baseado no nome do arquivo, sem a extensão .js) e um id do PM2. O PM2 também mantém outras informações, como o PID do processo, seu status atual e o uso de memória.

      Os aplicativos que estão funcionando sob o PM2 serão reiniciados automaticamente se o aplicativo falhar ou for encerrado, mas podemos ir um passo além para fazer o aplicativo iniciar na inicialização do sistema usando o subcomando startup. Este subcomando gera e configura um script de inicialização para iniciar o PM2 e seus processos gerenciados nas inicializações do servidor:

      A última linha da saída resultante incluirá um comando para ser executado com privilégios de superusuário para definir o PM2 para iniciar na inicialização:

      Output

      [PM2] Init System found: systemd sammy [PM2] To setup the Startup Script, copy/paste the following command: sudo env PATH=$PATH:/usr/bin /usr/lib/node_modules/pm2/bin/pm2 startup systemd -u sammy --hp /home/sammy

      Execute o comando a partir do resultado, com o seu nome de usuário no lugar de sammy:

      • sudo env PATH=$PATH:/usr/bin /usr/lib/node_modules/pm2/bin/pm2 startup systemd -u sammy --hp /home/sammy

      Como um passo adicional, podemos salvar a lista de processos PM2 e os ambientes correspondentes:

      Agora, você criou uma unidade systemd que executa o pm2 para seu usuário na inicialização. Esta instância pm2, por sua vez, executa o hello.js.

      Inicie o serviço com systemctl:

      • sudo systemctl start pm2-sammy

      Se neste ponto você encontrar um erro, pode ser necessário reinicializar o sistema. Isso pode ser feito com o sudo reboot.

      Verifique o status da unidade systemd:

      • systemctl status pm2-sammy

      Para um panorama detalhado do systemd, veja Systemd Essentials: Working with Services, Units, and the Journal.

      Além daqueles que abordamos, o PM2 fornece muitos subcomandos que permitem que você gerencie ou procure informações sobre seus aplicativos.

      Interrompa um aplicativo com este comando (especifique o App name do PM2 ou id):

      Reinicie um aplicativo:

      • pm2 restart app_name_or_id

      Liste os aplicativos atualmente gerenciados pelo PM2:

      Obtenha informações sobre um aplicativo específico usando seu App name:

      O monitor de processos do PM2 pode ser trazido com o subcomando monit. Isso mostra o status do aplicativo, da CPU, e o uso de memória:

      Note que executar o pm2 sem qualquer argumento também exibirá uma página de ajuda com exemplos de uso.

      Agora que seu aplicativo Node.js está funcionando e é gerenciado pelo PM2, vamos configurar o proxy reverso.

      Passo 4 — Configurando o Nginx como um Servidor de Proxy Reverso

      Seu aplicativo está funcionando e escutando no localhost, mas você precisa configurar uma forma dos seus usuários acesssarem ele. Vamos configurar o servidor Web Nginx como um proxy reverso com esse intuito.

      Nos pré-requisitos do tutorial, você definiu sua configuração do Nginx no arquivo /etc/nginx/sites-available/example.com. Abra este arquivo para edição:

      • sudo nano /etc/nginx/sites-available/example.com

      Dentro do bloco server, você deve ter um bloco location / existente. Substitua o conteúdo desse bloco com a seguinte configuração. Se seu aplicativo for configurado para escutar em uma porta diferente, atualize a parte em destaque com o número de porta correto:

      /etc/nginx/sites-available/example.com

      server {
      ...
          location / {
              proxy_pass http://localhost:3000;
              proxy_http_version 1.1;
              proxy_set_header Upgrade $http_upgrade;
              proxy_set_header Connection 'upgrade';
              proxy_set_header Host $host;
              proxy_cache_bypass $http_upgrade;
          }
      ...
      }
      

      Isso configura o servidor para responder a pedidos em sua raiz. Supondo que nosso servidor esteja disponível em example.com, acessar o https://example.com/ através de um navegador Web enviaria o pedido para hello.js, escutando na porta 3000 do localhost.

      Você pode adicionar blocos location adicionais ao mesmo bloco de servidor para fornecer acesso a outros aplicativos no mesmo servidor. Por exemplo, se você também estivesse executando outro aplicativo Node.js na porta 3001, você poderia adicionar este bloco de localização para permitir o acesso a ele através de https://example.com/app2:

      /etc/nginx/sites-available/example.com — Optional

      server {
      ...
          location /app2 {
              proxy_pass http://localhost:3001;
              proxy_http_version 1.1;
              proxy_set_header Upgrade $http_upgrade;
              proxy_set_header Connection 'upgrade';
              proxy_set_header Host $host;
              proxy_cache_bypass $http_upgrade;
          }
      ...
      }
      

      Assim que terminar de adicionar os blocos de localização para seus aplicativos, salve o arquivo e saia do seu editor.

      Certifique-se de que não tenha introduzido qualquer erro de sintaxe digitando:

      Reinicie o Nginx:

      • sudo systemctl restart nginx

      Supondo que o seu aplicativo Node.js esteja funcionando e o seu aplicativo e as configurações do Nginx estejam corretos, agora você deverá poder acessar seu aplicativo via proxy reverso do Nginx. Teste acessando o URL do seu servidor (seu endereço IP público ou nome de domínio).

      Conclusão

      Parabéns! Agora, você tem seu aplicativo Node.js funcionando atrás de um proxy reverso Nginx em um servidor Ubuntu 20.04. Esta configuração de proxy reverso é suficientemente flexível para fornecer o acesso aos seus usuários a outros aplicativos ou conteúdos Web estáticos que você queira compartilhar.



      Source link

      Como empacotar e publicar um aplicativo Snap no Ubuntu 18.04


      O autor selecionou a Electronic Frontier Foundation para receber uma doação como parte do programa Write for DOnations.

      Introdução

      Um dos maiores desafios no desenvolvimento de aplicativos é o passo final da distribuição do produto acabado para seus usuários ou clientes. Muitas metodologias existentes para implantação de aplicativos não são fáceis de usar e carecem de segurança, ou não fornecem métodos para atualizar automaticamente um aplicativo assim que estiver instalado.

      O Snap é um formato moderno de empacotamento de aplicativos, com recursos de área restrita e segurança eficazes, incluindo o isolamento do sistema de arquivos, atualizações automáticas e o gerenciamento de dependências integrado. Os aplicativos do Snap, conhecidos como Snaps, podem ser baixados e instalados usando um programa de linha de comando, de maneira semelhante às ferramentas apt ou yum. O Ubuntu vem com Snap pré-instalado, o que significa que há uma amplo público-alvo para os aplicativos Snap.

      Neste tutorial, você criará um aplicativo Snap e irá publicá-lo na Snap Store.

      Pré-requisitos

      Para completar este tutorial, você precisará de:

      • Um servidor Ubuntu 18.04 configurado de acordo com o tutorial de Configuração inicial de servidor com o Ubuntu 18.04, incluindo um usuário sudo não raiz.

      • Um aplicativo que você queira empacotar e lançar como um Snap. Esse pode ser um aplicativo complexo que você criou, um projeto de código aberto comum, ou um simples programa “Hello, world!” (“Olá, mundo!”) . Caso ainda não tenha um aplicativo, o Passo 1 deste tutorial irá abranger como criar um programa Hello World em Go.

      • Uma conta no Snapcraft Developer Snapcraft [Painel de desenvolvimento do Snapcraft].

      Assim que tiver tudo pronto, faça login no seu servidor como usuário não raiz para começar.

      Passo 1 — Preparando seu aplicativo para o empacotamento

      Primeiro, você irá preparar seu aplicativo para o empacotamento como um aplicativo Snap, assegurando que tudo o que é necessário esteja armazenado em um único diretório.

      Comece criando um diretório para seu Snap, acessando-o:

      • mkdir ~/your-snap
      • cd ~/your-snap

      Em seguida, caso já tenha um aplicativo, coloque uma cópia completa do código fonte do seu aplicativo no diretório que acabou de criar. O processo aqui será significativamente diferente, dependendo do aplicativo exato que estiver empacotando. No entanto, caso o código fonte estiver armazenado em um repositório do Git, você pode usar o comando git init para criar um repositório no diretório e puxar todo o código relevante.

      Caso ainda não tenha um aplicativo que deseja empacotar, você pode, em vez disso, criar um programa “Hello World” para usar. Caso queira mais contexto sobre como escrever esse programa com o Go, confira o tutorial Como escrever seu primeiro programa em Go.

      Você pode fazer isso, primeiramente criando um arquivo Go, abrindo-o com o seu editor de texto preferido:

      Depois, adicione o código a seguir ao arquivo:

      helloworld.go

      package main
      import "fmt"
      func main() {
        fmt.Println("Hello, world!")
      }
      

      Então, salve e saia do arquivo.

      Caso não tenha o Go instalado, instale-o usando o seguinte comando:

      • sudo apt install golang-go

      Assim que o Go estiver instalado, execute seu novo programa para verificar se ele está funcionando:

      Você verá o seguinte resultado:

      Output

      Hello, world!

      Você preparou seu aplicativo para empacotar como um Snap. Em seguida, você instalará o software necessário para iniciar o processo de empacotamento.

      Passo 2 — Instalando o Snapcraft

      Neste passo, você irá baixar e instalar o Snapcraft, que é o nome da ferramenta oficial de empacotamento do aplicativo Snap. O Snapcraft está disponível na Snap Store, que, por padrão, vem integrada ao Ubuntu. Isso significa que você pode instalar o Snapcraft a partir da linha de comando, usando o comando snap.

      O comando snap é equivalente ao comando apt, mas você pode usá-lo para instalar softwares da Snap Store, em vez de pacotes dos repositórios da Apt.

      Para instalar o Snapcraft, execute o seguinte comando:

      • sudo snap install snapcraft --classic

      Use o argumento de comando --classic para que o Snapcraft faça a instalação sem os recursos rigorosos de área restrita que os Snaps normalmente usam. O Snapcraft exige esse argumento, já que precisa de acesso mais privilegiado ao seu sistema para empacotar de maneira confiável os aplicativos.

      Assim que instalar o Snapcraft, verá o seguinte:

      Output

      snapcraft 3.9.8 from Canonical✓ installed

      Por fim, você pode verificar novamente a instalação do Snapcraft, executando:

      Isso exibirá algo similar a:

      Output

      snapcraft, version 3.9.8

      Agora que você instalou o Snapcraft, pode começar a definir a configuração e os metadados para o seu aplicativo Snap.

      Neste passo, você começará a definir a configuração, a estrutura e os metadados para seu aplicativo Snap.

      Comece certificando-se de que ainda está trabalhando no diretório do seu aplicativo Snap:

      Em seguida, crie e edite o arquivo snapcraft.yaml, usando seu editor de texto preferido:

      Você usará o arquivo snapcraft.yaml para armazenar toda a configuração do seu aplicativo Snap, incluindo o nome, descrição e versão, além de configurações relacionadas ao gerenciamento de dependências e ao uso de área restrita.

      Comece definindo o nome, resumo, descrição e número de versão do seu aplicativo:

      snapcraft.yaml

      name: your-snap
      summary: A summary of your application in 78 characters or less.
      description: |
        A detailed description of your application.
        The description can have multiple lines.
      version: '1.0'
      

      O nome do seu Snap precisa ser único caso deseje publicá-lo na Snap Store — procure outros aplicativos com o mesmo nome para garantir que ele já não esteja sendo usado.

      Em seguida, defina o(s) comando(s) que deseja associar ao seu aplicativo. Isso permitirá que seu Snap seja usado diretamente a partir da linha de comando do Bash, como um comando normal.

      Adicione o seguinte ao seu arquivo snapcraft.yaml:

      snapcraft.yaml

      . . .
      apps:
        your-snap-command:
          command: your-snap
      

      your-snap-command é o nome do comando que deseja definir. Por exemplo, pode ser que queira usar o comando helloworld para executar seu programa Hello World.

      Você usará o command: your-snap para dizer ao Snapcraft o que fazer quando o comando do aplicativo for executado. No caso do programa Hello World, você usaria o valor helloworld para fazer referência ao arquivo helloworld.go, o que permitirá que o Snapcraft execute seu programa com sucesso.

      Isso resulta na seguinte configuração de exemplo:

      snapcraft.yaml

      apps:
        helloworld:
          command: helloworld
      

      Caso o nome do comando corresponda exatamente ao nome do Snap, você será capaz de executá-lo diretamente da linha de comando. Caso o comando não corresponda ao nome do Snap, o comando será prefixado automaticamente com o nome do Snap. Por exemplo, helloworld.command1.

      Por fim, você pode definir as partes que compõem seu aplicativo Snap. Os aplicativos Snap consistem em várias partes, as quais são todos os componentes que compõem seu aplicativo. Em muitos casos, há apenas uma parte, que é o aplicativo propriamente dito.

      Cada parte tem um plug-in associado. Por exemplo, para os componentes do seu aplicativo escritos em Ruby, o plug-in ruby é usado e, para os componentes escritos em Go, o plug-in go é usado.

      Use o comando list-plugins do Snapcraft para identificar o(s) plug-in(s) correto(s) para seu aplicativo:

      Isso irá gerar uma lista parecida com a seguinte:

      Output

      ant catkin-tools conda dump gradle make nil python rust autotools cmake crystal go kbuild maven nodejs qmake scons catkin colcon dotnet godeps kernel meson plainbox-provider ruby waf

      Os plug-ins mais comuns são os para linguagens de programação comuns, como Go, Rust, Ruby, ou Python.

      Assim que tiver identificado os plug-ins corretos para o seu aplicativo, você pode começar a adicionar a configuração das parts (partes) ao seu arquivo snapcraft.yaml:

      snapcraft.yaml

      . . .
      parts:
        your-snap:
          plugin: plugin-name
          source: .
      

      Utilize o parâmetro de configuração source para especificar o caminho relativo para o código fonte para o seu aplicativo. Normalmente, esse será o mesmo diretório do arquivo snapcraft.yaml em si. Assim, o valor source é um único ponto (.).

      Nota: caso o componente de seu aplicativo tenha quaisquer dependências que sejam necessárias para que o compile ou execute, você pode especificá-las usando os atributos build-packages e stage-packages. Os nomes de dependências especificados serão, então, obtidos automaticamente com o gerenciador de pacotes padrão para seu sistema.

      Por exemplo:

      snapcraft.yaml

      parts:
        your-snap:
        plugin: plugin-name
        source: .
        build-packages:
        - gcc
        - make
        stage-packages:
        - libcurl4
      

      Alguns plug-ins do Snapcraft têm suas próprias opções específicas que podem ser necessárias para seu aplicativo. Assim, vale a pena rever as páginas relevantes do manual do seu plug-in:

      • snapcraft help plugin-name

      No caso dos aplicativos Go, você também especificaria o caminho go-importpath. Para a configuração Hello World, isso resulta na seguinte configuração de exemplo:

      snapcraft.yaml

      parts:
        helloworld:
          plugin: go
          source: .
          go-importpath: helloworld
      

      Deixe seu arquivo snapcraft.yaml aberto para adicionar mais configurações no próximo passo.

      Você definiu a configuração base para seu aplicativo Snap. Em seguida, você irá configurar os aspectos de segurança e de área restrita do seu aplicativo.

      Passo 4 — Protegendo seu aplicativo Snap

      Os aplicativos Snap foram criados para executarem em um ambiente de área restrita, de modo que, neste passo, você irá configurar a área restrita para o seu Snap. Primeiro, precisará habilitar a área restrita para o seu aplicativo, conhecida dentro do Snapcraft como confinement (confinamento).

      Adicione o seguinte ao seu arquivo snapcraft.yaml:

      snapcraft.yaml

      . . .
      confinement: strict
      

      Isso habilitará a área restrita para o seu aplicativo, impedindo-o de acessar a internet, outros Snaps em execução, ou o sistema do host propriamente dito. No entanto, na maioria dos casos, os aplicativos precisam ser capazes de se comunicar fora da área restrita, como quando precisam acessar a internet ou ler/gravar no sistema de arquivos.

      Essas permissões, conhecidas dentro do Snapcraft como interfaces, podem ser concedidas ao seu aplicativo Snap usando os Plugs. Usando o Plugs, você pode ter o controle fino sobre a área restrita do seu aplicativo, para lhe dar o acesso que precisa e nada mais (princípio do menor privilégio).

      As interfaces exatas que são necessárias variam, dependendo do seu aplicativo. Algumas das interfaces mais comuns são:

      • audio-playback – permite saída de som/reprodução de sons.
      • audio-record – permite a entrada/gravação de áudio.
      • camera – permite o acesso a webcams conectadas.
      • home – permite o acesso a arquivos não ocultos dentro do seu diretório home.
      • network – permite o acesso à rede/internet.
      • network-bind – permite a vinculação às portas para operar como um serviço de rede.
      • system-files – permite o acesso ao sistema de arquivos completo da máquina de hospedagem.

      A lista completa de interfaces disponíveis pode ser encontrada dentro da documentação do Snapcraft, em Interfaces compatíveis.

      Assim que tiver identificado todas as interfaces necessárias para o seu aplicativo, você pode começar a atribuí-las aos plugs dentro do seu arquivo snapcraft.yaml.

      A configuração do exemplo a seguir permitirá que o aplicativo acesse a rede e a área inicial de usuários:

      snapcraft.yaml

      . . .
      plugs:
        your-snap-home:
          interface: home
        your-snap-network:
          interface: network
      

      Salve e saia do seu arquivo.

      O nome do Plug deve ser um nome descritivo para ajudar os usuários a identificar o propósito do Plug.

      Você habilitou a área restrita para o seu Snap e configurou alguns Plugs para conceder acesso limitado aos recursos do sistema. Em seguida, terminará a compilação do seu app Snap.

      Passo 5 — Compilando e testando seu aplicativo Snap

      Agora que você escreveu toda a configuração necessária para o seu Snap, prossiga com a compilação e teste do pacote Snap localmente.

      Caso esteja acompanhando este tutorial com a utilização de um programa Hello World como seu aplicativo, seu arquivo completo snapcraft.yaml será agora semelhante ao seguinte:

      snapcraft.yaml

      name: helloworld
      summary: A simple Hello World program.
      description: |
        A simple Hello World program written in Go.
        Packaged as a Snap application using Snapcraft.
      version: '1.0'
      confinement: strict
      
      apps:
        helloworld:
          command: helloworld
      
      parts:
        helloworld:
          plugin: go
          source: .
          go-importpath: helloworld
      
      plugs:
        helloworld-home:
          interface: home
        helloworld-network:
          interface: network
      

      Para compilar seu aplicativo Snap, execute o comando snapcraft dentro do diretório para seu Snap:

      Então, o Snapcraft irá iniciar automaticamente uma máquina virtual (VM) e começará a compilar seu Snap. Assim que terminar, o Snapcraft fechará e você verá algo semelhante ao seguinte:

      Output

      Snapped your-snap_1.0_amd64.snap

      Agora, você pode instalar o seu Snap localmente para verificar se ele está funcionando:

      • sudo snap install your-snap.snap --dangerous

      O argumento de comando --dangerous é necessário, já que você está instalando um Snap local que não foi assinado.

      Output

      your-snap 1.0 installed

      Assim que o processo de instalação estiver completo, execute seu Snap usando seu comando associado. Por exemplo:

      No caso do programa exemplo Hello World, o resultado seguinte seria:

      Output

      Hello, world!

      Você também pode visualizar a política de área restrita para seu Snap para se certificar de que as permissões atribuídas foram devidamente concedidas:

      • snap connections your-snap

      Isso irá gerar uma lista de Plugs e interfaces, parecida com a seguinte:

      Output

      snap connections your-snap Interface Plug Slot Notes home your-snap:your-snap-home :home - network your-snap:your-snap-network :network -

      Neste passo, você construiu seu Snap e o instalou localmente para testar se ele está funcionando. Em seguida, irá publicar seu Snap na Snap Store.

      Passo 6 — Publicando seu Snap

      Agora que você compilou e testou seu aplicativo Snap, é hora de lançá-lo na Snap Store.

      Comece fazendo login na sua conta de desenvolvedor do Snap, usando o aplicativo de linha de comando Snapcraft:

      Siga os prompts e digite seu endereço de e-mail e senha.

      Em seguida, você precisa registrar o nome do aplicativo na Snap Store:

      • snapcraft register your-snap

      Assim que tiver registrado o nome do Snap, poderá enviar o pacote do Snap compilado para a loja:

      • snapcraft push your-snap.snap

      Você verá um resultado similar ao seguinte:

      Output

      Preparing to push 'your-snap_1.0_amd64.snap'. Install the review-tools from the Snap Store for enhanced checks before uploading this snap. Pushing 'your-snap_1.0_amd64.snap' [===================================================================================================] 100% Processing...| Ready to release! Revision 1 of 'your-snap' created.

      Cada vez que você manda para a loja do Snap, o número de revisão é incrementado, começando em um. Isso é útil para ajudar a identificar as diferentes compilações do seu Snap.

      Por fim, você pode lançar seu Snap para o público:

      • snapcraft release your-snap revision-number channel

      Caso essa seja a primeira vez que você envia algo para a Snap Store, o número da revisão será 1. Você também pode escolher entre lançar nos canais stable, candidate, beta e edge, caso tenha várias versões do seu aplicativo em diferentes fases de desenvolvimento.

      Por exemplo, o comando a seguir lançará a revisão 1 do Snap Hello World no canal stable:

      • snapcraft release helloworld 1 stable

      Você verá um resultado similar ao seguinte:

      Output

      Track Arch Channel Version Revision latest amd64 stable 1.0 1 candidate ^ ^ beta ^ ^ edge ^ ^ The 'stable' channel is now open.

      Agora, você pode procurar pelo seu aplicativo na Snap Store e instalá-lo em qualquer um dos seus dispositivos.

      Loja do Snapcraft com o app Hello World exibido nos resultados de busca

      Neste passo final, você enviou seu pacote compilado do Snap para a Snap Store e o lançou para o público.

      Conclusão

      Neste artigo, você configurou e compilou um aplicativo Snap e, depois, lançou-o para o público através da Snap Store. Agora, possui o conhecimento básico necessário para manter o seu aplicativo e compilar novos.

      Caso queira explorar os Snaps ainda mais, confira a Snap Store completa. Você também pode querer rever a referência YAML do Snapcraft para entender mais sobre ela e identificar atributos adicionais para sua configuração do Snap.

      Por fim, caso queira investigar ainda mais o desenvolvimento do Snap, pode ser que goste de ler sobre a implementação de Snap Hooks, que permitem que os Snaps reajam dinamicamente às alterações do sistema, como as atualizações ou ajustes de política de segurança.



      Source link

      Como adicionar o Sidekiq e o Redis a um aplicativo Ruby on Rails


      Introdução

      Ao desenvolver um aplicativo Ruby on Rails, você pode se deparar com tarefas de aplicativos que devem ser executadas de maneira assíncrona. O processamento de dados, envio de e-mails em lote, ou a interação com APIs externas são todos exemplos de trabalho que podem ser feitos de maneira assíncrona com o background jobs. O uso de jobs em segundo plano pode melhorar o desempenho de seu aplicativo, descarregando tarefas potencialmente demoradas em uma fila de processamento em segundo plano, liberando o ciclo de solicitação/resposta original.

      O Sidekiq é uma das frameworks mais amplamente utilizadas em jobs de segundo plano que você pode implementar em um aplicativo Rails. Ele é apoiado pelo Redis, um armazenamento de valores-chave dentro da memória conhecido pela sua flexibilidade e desempenho. O Sidekiq utiliza o Redis como um armazenamento de gerenciamento de tarefas para processar milhares de tarefas por segundo.

      Neste tutorial, você adicionará o Redis e o Sidekiq a um aplicativo existente do Rails. Você criará um conjunto de classes e métodos de trabalho do Sidekiq para lidar com:

      • Um upload em lote de informações de tubarões ameaçados de extinção para o banco de dados do aplicativo de um arquivo CSV no repositório de projeto.
      • A remoção desses dados.

      Quando terminar, terá um aplicativo de demonstração que utilizará trabalhadores e trabalhos para processar tarefas de maneira assíncrona. Esta será uma boa base para que você adicione trabalhadores e trabalhos ao seu próprio aplicativo, usando este tutorial como um ponto de partida.

      Pré-requisitos

      Para seguir este tutorial, você vai precisar do seguinte:

      Passo 1 — Clonando o projeto e instalando dependências

      Nosso primeiro passo será clonar o repositório de rails-bootstrap da conta do GitHub da Comunidade da DigitalOcean. Esse repositório inclui o código da configuração descrita em Como adicionar o Bootstrap em um aplicativo Ruby on Rails, que explica como adicionar o Bootstrap a um projeto Rails 5 existente.

      Clone o repositório em um diretório chamado rails-sidekiq:

      • git clone https://github.com/do-community/rails-bootstrap.git rails-sidekiq

      Navegue até o diretório rails-sidekiq:

      Para trabalhar com o código, primeiro será necessário instalar as dependências do projeto, que estão listadas em seu Gemfile. Você também precisará adicionar o sidekiq gem ao projeto para trabalhar com o Sidekiq e o Redis.

      Abra o Gemfile do projeto para editá-lo usando o nano ou seu editor favorito:

      Adicione a gem em qualquer lugar das dependências principais do projeto (acima das dependências de desenvolvimento):

      ~/rails-sidekiq/Gemfile

      . . .
      # Reduces boot times through caching; required in config/boot.rb
      gem 'bootsnap', '>= 1.1.0', require: false
      gem 'sidekiq', '~>6.0.0'
      
      group :development, :test do
      . . .
      

      Salve e feche o arquivo quando terminar de adicionar o gem.

      Use o seguinte comando para instalar os gems:

      Você verá na saída que o redis gem também está instalado como um requisito para o sidekiq.

      Em seguida, você instalará suas dependências do Yarn. Como esse projeto Rails 5 foi modificado para atender ativos com o webpack, as dependências de JavaScript dele são gerenciadas agora pelo Yarn. Isso significa que é necessário instalar e verificar as dependências listadas no arquivo do projeto package.json.

      Execute o yarn install para instalar essas dependências:

      Em seguida, execute seu banco de dados de migrações:

      Assim que suas migrações terminarem, teste o aplicativo para garantir que ele esteja funcionando como esperado. Caso esteja trabalhando localmente, inicie seu servidor no contexto do seu pacote local com o seguinte comando:

      Caso esteja trabalhando em um servidor de desenvolvimento, inicie o aplicativo com:

      • bundle exec rails s --binding=your_server_ip

      Navegue até o localhost:3000 ou http://your_server_ip:3000. Você verá a seguinte página inicial:

      Página inicial do aplicativo

      Para criar um novo tubarão, clique no botão Get Shark Info, que levará você até a rota sharks/index:

      Rota do Índice de Tubarões

      Para verificar se o aplicativo está funcionando, podemos adicionar algumas informações de demonstração a ele. Clique em New Shark. Será solicitado que coloque um nome de usuário (sammy) e senha (shark), graças às configurações de autenticação do projeto.

      Na página New Shark, digite “Great White” no campo Name e “Scary” no campo Facts.

      Criar Tubarão

      Clique no botão Create Shark para criar o tubarão. Assim que ver que seu tubarão foi criado, encerre o servidor com CTRL+C.

      Você instalou as dependências necessárias para seu projeto e testou sua funcionalidade. Em seguida, você pode fazer algumas alterações no aplicativo Rails para trabalhar com seus recursos de tubarões ameaçados de extinção.

      Passo 2 — Gerando um controlador para recursos de tubarões ameaçados de extinção

      Para trabalhar com nossos recursos de tubarões ameaçados de extinção, adicionaremos um novo modelo ao aplicativo e um controlador que controlará como as informações sobre tubarões ameaçados de extinção serão apresentadas aos usuários. Nosso objetivo final é tornar possível que os usuários enviem um lote grande de informações sobre tubarões ameaçados de extinção sem bloquear a funcionalidade geral do nosso aplicativo e excluírem essas informações quando não precisarem mais delas.

      Primeiro, vamos criar um modelo Endangered para nossos tubarões ameaçados de extinção. Vamos incluir um campo string em nossa tabela de banco de dados para o nome do tubarão e outro campo string para as categorias da União Internacional para a Conservação da Natureza (IUCN), que determina o grau em que cada tubarão está em risco.

      Por fim, nossa estrutura de modelo corresponderá às colunas do arquivo CSV que usaremos para criar nosso upload do lote. Este arquivo está localizado no diretório db e você pode verificar seu conteúdo com o seguinte comando:

      O arquivo contém uma lista de 73 tubarões ameaçados de extinção e seus status de IUCN – vu para vulneráveis, en para ameaçados de extinção e cr para criticamente ameaçados de extinção.

      Nosso modelo Endangered se correlacionará com esses dados, permitindo-nos criar novas instâncias de Endangered a partir deste arquivo CSV. Crie o modelo com o seguinte comando:

      • rails generate model Endangered name:string iucn:string

      Em seguida, gere um controlador Endangered com uma ação index:

      • rails generate controller endangered index

      Isso nos dará um ponto de partida para desenvolver a funcionalidade do nosso aplicativo, embora também seja necessário adicionar métodos personalizados ao arquivo do controlador que o Rails gerou para nós.

      Abra aquele arquivo agora:

      • nano app/controllers/endangered_controller.rb

      O Rails nos forneceu um rascunho que podemos começar a preencher.

      Primeiro, vamos precisar determinar quais rotas precisamos trabalhar com nossos dados. Graças ao comando generate controller, temos um método index para começar. Isso se correlacionará a uma visualização do index, onde apresentaremos usuários com a opção de fazer o upload de tubarões ameaçados de extinção.

      No entanto, também queremos lidar com casos onde os usuários podem já ter feito upload dos tubarões; eles não precisarão de uma opção de upload neste caso. De algum modo precisaremos avaliar quantas instâncias da classe Endangered já existem, uma vez que mais de uma indica que o upload do lote já ocorreu.

      Vamos começar criando um método private set_endangered que capturará cada instância de nossa classe Endangered a partir do banco de dados. Adicione o código a seguir ao arquivo:

      ~/rails-sidekiq/app/controllers/endangered_controller.rb

      class EndangeredController < ApplicationController
        before_action :set_endangered, only: [:index, :data]
      
        def index
        end
      
        private
      
          def set_endangered
            @endangered = Endangered.all
          end
      
      end
      

      Note que o filtro before_action garantirá que o valor @endangered seja definido apenas para as rotas index e data, que serão as rotas onde lidaremos com os dados dos tubarões ameaçados de extinção.

      Em seguida, adicione o seguinte código ao método index para determinar a rota correta para usuários visitando esta parte do aplicativo:

      ~/rails-sidekiq/app/controllers/endangered_controller.rb

      class EndangeredController < ApplicationController
        before_action :set_endangered, only: [:index, :data]
      
        def index          
          if @endangered.length > 0
            redirect_to endangered_data_path
          else
            render 'index'
          end
        end
      . . .
      

      Caso não exista nenhuma instância de nossa classe Endangered, redirecionaremos os usuários para a rota data, onde podem visualizar informações sobre os tubarões que eles criaram. Caso contrário, eles visualizarão o index.

      Em seguida, abaixo do método index, adicione um método data, que se correlacionará a uma visualização do método data:

      ~/rails-sidekiq/app/controllers/endangered_controller.rb

      . . .
        def index          
          if @endangered.length > 0
            redirect_to endangered_data_path
          else
            render 'index'
          end
        end
      
        def data
        end
      . . .
      

      Em seguida, adicionaremos um método para lidar com o upload de dados propriamente dito. Vamos chamar este método de upload e chamaremos uma classe trabalhadora e um método Sidekiq para realizar o upload de dados do arquivo CSV. Criaremos a definição para essa classe trabalhadora, AddEndangeredWorker, no próximo passo.

      Por enquanto, adicione o seguinte código ao arquivo para fazer o trabalhador do Sidekiq realizar o upload:

      ~/rails-sidekiq/app/controllers/endangered_controller.rb

      . . .
        def data
        end
      
        def upload
          csv_file = File.join Rails.root, 'db', 'sharks.csv'   
          AddEndangeredWorker.perform_async(csv_file)
          redirect_to endangered_data_path, notice: 'Endangered sharks have been uploaded!'
        end
      . . .
      

      Ao chamar o método perform_async da classe AddEndangeredWorker usando o arquivo CSV como um argumento, este código garante que os dados do tubarão e o trabalho de upload sejam passados para o Redis. Os trabalhadores do Sidekiq que vamos configurar monitoram a fila de trabalho e reagirão quando novos trabalhos surgirem.

      Após chamar o perform_async, nosso método de upload redireciona para o caminho data, onde os usuários poderão ver os tubarões carregados.

      Em seguida, adicionaremos um método destroy para destruir os dados. Adicione o seguinte código abaixo do método do upload:

      ~/rails-sidekiq/app/controllers/endangered_controller.rb

      . . .
        def upload
          csv_file = File.join Rails.root, 'db', 'sharks.csv'   
          AddEndangeredWorker.perform_async(csv_file)
          redirect_to endangered_data_path, notice: 'Endangered sharks have been uploaded!'
        end
      
        def destroy
          RemoveEndangeredWorker.perform_async
          redirect_to root_path
        end
      . . .
      

      Da mesma forma que nosso método de upload, nosso método destroy inclui uma chamada do perform_async de uma classe RemoveEndangeredWorker — o outro trabalhador Sidekiq que vamos criar. Após chamar este método, ele redireciona os usuários para o caminho do aplicativo raiz.

      O arquivo final se parecerá com este:

      ~/rails-sidekiq/app/controllers/endangered_controller.rb

      class EndangeredController < ApplicationController
        before_action :set_endangered, only: [:index, :data]
      
        def index          
          if @endangered.length > 0
            redirect_to endangered_data_path
          else
            render 'index'
          end
        end
      
        def data
        end
      
        def upload
          csv_file = File.join Rails.root, 'db', 'sharks.csv'   
          AddEndangeredWorker.perform_async(csv_file)
          redirect_to endangered_data_path, notice: 'Endangered sharks have been uploaded!'
        end
      
        def destroy
          RemoveEndangeredWorker.perform_async
          redirect_to root_path
        end
      
        private
      
          def set_endangered
            @endangered = Endangered.all
          end
      
      end
      

      Salve e feche o arquivo quando você terminar a edição.

      Como passo final na consolidação das rotas do nosso aplicativo, vamos modificar o código em config/routes.rb, o arquivo onde ficam nossas declarações de rota.

      Abra aquele arquivo agora:

      O arquivo se parece com esse:

      ~/rails-sidekiq/config/routes.rb

      Rails.application.routes.draw do
        get 'endangered/index'
        get 'home/index'
        resources :sharks do
                resources :posts
        end
        root 'home#index'
        # For details on the DSL available within this file, see http://guides.rubyonrails.org/routing.html
      end
      

      Vamos precisar atualizar o arquivo para incluir as rotas que definimos em nosso controlador: data, upload e destroy. Nossa rota de data corresponderá a uma solicitação GET para recuperar os dados do tubarão, enquanto nossas rotas de upload e destroy mapearão as solicitações POST, que farão o upload e a destruição desses dados.

      Adicione o código a seguir ao arquivo para definir essas rotas:

      ~/rails-sidekiq/config/routes.rb

      Rails.application.routes.draw do
        get 'endangered/index'
        get 'endangered/data', to: 'endangered#data'
        post 'endangered/upload', to: 'endangered#upload'
        post 'endangered/destroy', to: 'endangered#destroy'
        get 'home/index'
        resources :sharks do
                resources :posts
        end
        root 'home#index'
        # For details on the DSL available within this file, see http://guides.rubyonrails.org/routing.html
      end
      

      Salve e feche o arquivo quando você terminar a edição.

      Com seu modelo e controlador Endangered em funcionamento, continue para definir suas classes de trabalhadores do Sidekiq.

      Passo 3 — Definindo os trabalhadores do Sidekiq

      Chamamos os métodos do perform_async nos trabalhadores do Sidekiq em nosso controlador, mas ainda precisamos criar os trabalhadores em si.

      Primeiro, crie um diretório workers para os trabalhadores:

      Abra um arquivo para o trabalhador AddEndangeredWorker:

      • nano app/workers/add_endangered_worker.rb

      Neste arquivo, adicionaremos códigos que nos permitirá trabalhar com os dados em nosso arquivo CSV. Primeiro, adicione códigos ao arquivo que criarão a classe, inclua a biblioteca Ruby CSV e certifique-se de que essa classe funcione como um trabalhador Sidekiq:

      ~/rails-sidekiq/app/workers/add_endangered_worker.rb

      class AddEndangeredWorker
        require 'csv'
        include Sidekiq::Worker
        sidekiq_options retry: false
      
      end
      

      Também incluiremos a opção retry: false para garantir que o Sidekiq não tente fazer o upload novamente em caso de falha.

      Em seguida, adicione o código para a função perform:

      ~/rails-sidekiq/app/workers/add_endangered_worker.rb

      class AddEndangeredWorker
        require 'csv'
        include Sidekiq::Worker
        sidekiq_options retry: false
      
        def perform(csv_file)
          CSV.foreach(csv_file, headers: true) do |shark|
          Endangered.create(name: shark[0], iucn: shark[1])
        end
       end
      
      end
      

      O método perform recebe argumentos do método perform_async definido no controlador, por este motivo, é importante que os valores do argumento estejam alinhados. Aqui, passamos a csv_file, a variável que definimos no controlador, e usamos o método foreach da biblioteca CSV para ler os valores no arquivo. Definir headers: true para este loop garante que a primeira linha do arquivo seja tratada como uma linha de cabeçalhos.

      Então, o bloco lê os valores do arquivo nas colunas que definimos para nosso modelo Endangered: name e iucn. Executar este loop criará instâncias Endangered para cada uma das entradas em nosso arquivo CSV.

      Assim que terminar a edição, salve e feche o arquivo.

      Em seguida, criaremos um trabalhador para lidar com a exclusão desses dados. Abra um arquivo para a classe RemoveEndangeredWorker:

      • nano app/workers/remove_endangered_worker.rb

      Adicione o código a seguir para definir a classe, e para garantir que ela utilize a biblioteca e as funções CSV como um trabalhador Sidekiq:

      ~/rails-sidekiq/app/workers/remove_endangered_worker.rb

      class RemoveEndangeredWorker
        include Sidekiq::Worker
        sidekiq_options retry: false
      
      end
      

      Em seguida, adicione um método perform para lidar com a destruição dos dados dos tubarões ameaçados de extinção:

      ~/rails-sidekiq/app/workers/remove_endangered_worker.rb

      class RemoveEndangeredWorker
        include Sidekiq::Worker
        sidekiq_options retry: false
      
        def perform
          Endangered.destroy_all
        end
      
      end
      

      O método perform chama a função destroy_all na classe Endangered, que removerá todas as instâncias da classe a partir do banco de dados.

      Salve e feche o arquivo quando você terminar a edição.

      Com seus trabalhadores em funcionamento, continue para a criação de um layout para suas visualizações de endangered e a criação de modelos para a visualização de seus index e data, de modo que os usuários possam fazer upload e visualizar tubarões ameaçados de extinção.

      Passo 4 — Adicionando layouts e modelos de visualização

      Para que os usuários aproveitem suas informações de tubarões ameaçados de extinção, precisaremos abordar duas coisas: o layout para as visualizações definidas em nosso controlador endangered e os modelos de visualização para as visualizações de index e de data.

      Atualmente, nosso aplicativo utiliza um layout em todo o aplicativo, localizado em app/views/layouts/application.html.erb, uma navegação parcial e um layout para visualizações de sharks. O layout do aplicativo verifica se há um bloco de conteúdo que nos permita carregar diferentes layouts com base em qual parte do aplicativo nosso usuário se encontra: para a home index, os usuários verão um layout, e para quaisquer visualizações relacionadas a tubarões individuais, eles verão outro layout.

      Podemos reaproveitar o layout sharks para nossas visualizações endangered, uma vez que este formato também funcionará para a apresentação de dados de tubarões em massa.

      Copie o arquivo de layout de sharks para criar um layout de endangered:

      • cp app/views/layouts/sharks.html.erb app/views/layouts/endangered.html.erb

      Em seguida, vamos trabalhar na criação dos modelos de visualização para nossas visualizações de index e de data.

      Abra o modelo index primeiro:

      • nano app/views/endangered/index.html.erb

      Exclua o código boilerplate e adicione o código a seguir, o qual dará informações gerais aos usuários sobre as categorias ameaçados de extinção e os apresentará com a opção de fazer o upload das informações sobre eles:

      ~/rails-sidekiq/app/views/endangered/index.html.erb

      <p id="notice"><%= notice %></p>
      
      <h1>Endangered Sharks</h1>
      
      <p>International Union for Conservation of Nature (ICUN) statuses: <b>vu:</b> Vulnerable, <b>en:</b> Endangered, <b>cr:</b> Critically Endangered </p>
      
      <br>
      
        <%= form_tag endangered_upload_path do %>
        <%= submit_tag "Import Endangered Sharks" %>
        <% end %>
      
        <br>
      
      <%= link_to 'New Shark', new_shark_path, :class => "btn btn-primary btn-sm" %> <%= link_to 'Home', home_index_path, :class => "btn btn-primary btn-sm" %>
      

      Uma form_tag torna o upload de dados possível, apontando uma ação posterior para a endangered_upload_path — a rota que definimos para nossos uploads. Um botão de enviar, criado com o submit_tag, solicita que os usuários façam o "Import Endangered Sharks​".

      Além deste código, incluímos algumas informações gerais sobre os códigos ICUN, de modo que os usuários possam interpretar os dados que eles verão.

      Salve e feche o arquivo quando você terminar a edição.

      Em seguida, abra um arquivo para a visualização de data:

      • nano app/views/endangered/data.html.erb

      Adicione o código a seguir, que adicionará uma tabela com os dados de tubarões ameaçados de extinção:

      ~/rails-sidekiq/app/views/endangered/data.html.erb

      <p id="notice"><%= notice %></p>
      
      <h1>Endangered Sharks</h1>
      
      <p>International Union for Conservation of Nature (ICUN) statuses: <b>vu:</b> Vulnerable, <b>en:</b> Endangered, <b>cr:</b> Critically Endangered </p>
      
      <div class="table-responsive">
      <table class="table table-striped table-dark">
        <thead>
          <tr>
            <th>Name</th>
            <th>IUCN Status</th>
            <th colspan="3"></th>
          </tr>
        </thead>
      
        <tbody>
          <% @endangered.each do |shark| %>
            <tr>
              <td><%= shark.name %></td>
              <td><%= shark.iucn %></td>
            </tr>
          <% end %>
        </tbody>
      </table>
      </div>
      
      <br>
      
        <%= form_tag endangered_destroy_path do %>
        <%= submit_tag "Delete Endangered Sharks" %>
        <% end %>
      
        <br>
      
      <%= link_to 'New Shark', new_shark_path, :class => "btn btn-primary btn-sm" %> <%= link_to 'Home', home_index_path, :class => "btn btn-primary btn-sm" %>
      

      Esse código inclui os códigos de status da ICUN novamente e uma tabela de Inicialização para os dados produzidos. Ao fazer loop através de nossa variável @endangered, produziremos o nome e o status de ICUN de cada tubarão para a tabela.

      Abaixo da tabela, temos outro conjunto de form_tags e de submit_tags que foram enviados para o caminho destroy, oferecendo aos usuários a opção "Delete Endangered Sharks".

      Salve e feche o arquivo quando você terminar a edição.

      A última modificação que vamos fazer às visualizações será feita na visualização de index associada ao nosso controlador home. Você deve se lembrar de que essa visualização está definida como a raiz do aplicativo em config/routes.rb.

      Abra este arquivo para edição:

      • nano app/views/home/index.html.erb

      Encontre a coluna na linha que afirma que Sharks are ancient​​​:

      ~/rails-sidekiq/app/views/home/index.html.erb

      . . .
              <div class="col-lg-6">
                  <h3>Sharks are ancient</h3>
                  <p>There is evidence to suggest that sharks lived up to 400 million years ago.
                  </p>
              </div>
          </div>
      </div>
      

      Adicione o código a seguir ao arquivo:

      ~/rails-sidekiq/app/views/home/index.html.erb

      . . .
              <div class="col-lg-6">
                  <h3>Sharks are ancient and SOME are in danger</h3>
                  <p>There is evidence to suggest that sharks lived up to 400 million years ago. Without our help, some could disappear soon.</p>
                  <p><%= button_to 'Which Sharks Are in Danger?', endangered_index_path, :method => :get,  :class => "btn btn-primary btn-sm"%>
                  </p>
              </div>
          </div>
      </div>
      

      Incluímos uma chamada de ação para os usuários aprenderem mais sobre os tubarões ameaçados de extinção, primeiramente compartilhando uma mensagem importante e, em seguida, adicionando um auxiliar button_to que envia uma solicitação GET para nossa rota de endangered index, dando acesso a essa parte do aplicativo. A partir daí, eles poderão fazer o upload e visualizar informações sobre tubarões ameaçados de extinção.

      Salve e feche o arquivo quando você terminar a edição.

      Com seu código funcionando, você está pronto para inicializar o aplicativo e fazer o upload de alguns tubarões!

      Passo 5 — Inicializando o Sidekiq e testando o aplicativo

      Antes de inicializar o aplicativo, precisaremos executar as migrações em nosso banco de dados e iniciar o Sidekiq para habilitar nossos trabalhadores. O Redis já deve estar em execução no servidor, mas podemos verificar isso para termos certeza. Com tudo isso funcionando, estaremos prontos para testar o aplicativo.

      Primeiro, verifique se o Redis está funcionando:

      Deverá ver um resultado como o seguinte:

      Output

      ● redis-server.service - Advanced key-value store Loaded: loaded (/lib/systemd/system/redis-server.service; enabled; vendor preset: enabled) Active: active (running) since Tue 2019-11-12 20:37:13 UTC; 1 weeks 0 days ago

      Em seguida, execute seu banco de dados de migrações:

      Agora, você pode iniciar o Sidekiq no contexto do seu pacote atual do projeto, usando o comando bundle exec sidekiq​​​:

      Você verá um resultado como este, indicando que o Sidekiq está pronto para processar trabalhos:

      Output

      m, `$b .ss, $$: .,d$ `$$P,d$P' .,md$P"' ,$$$$$b/md$$$P^' .d$$$$$$/$$$P' $$^' `"/$$$' ____ _ _ _ _ $: ,$$: / ___|(_) __| | ___| | _(_) __ _ `b :$$ ___ | |/ _` |/ _ |/ / |/ _` | $$: ___) | | (_| | __/ <| | (_| | $$ |____/|_|__,_|___|_|__|__, | .d$$ |_| 2019-11-19T21:43:00.540Z pid=17621 tid=gpiqiesdl INFO: Running in ruby 2.5.1p57 (2018-03-29 revision 63029) [x86_64-linux] 2019-11-19T21:43:00.540Z pid=17621 tid=gpiqiesdl INFO: See LICENSE and the LGPL-3.0 for licensing details. 2019-11-19T21:43:00.540Z pid=17621 tid=gpiqiesdl INFO: Upgrade to Sidekiq Pro for more features and support: http://sidekiq.org 2019-11-19T21:43:00.540Z pid=17621 tid=gpiqiesdl INFO: Booting Sidekiq 6.0.3 with redis options {:id=>"Sidekiq-server-PID-17621", :url=>nil} 2019-11-19T21:43:00.543Z pid=17621 tid=gpiqiesdl INFO: Starting processing, hit Ctrl-C to stop

      Abra uma segunda janela de terminal, navegue para o diretório rails-sidekiq e inicialize seu servidor do aplicativo.

      Caso esteja executando o aplicativo localmente, use o seguinte comando:

      Caso esteja trabalhando com um servidor de desenvolvimento, execute o seguinte:

      • bundle exec rails s --binding=your_server_ip

      Navegue para o localhost:3000 ou http://your_server_ip:3000 no navegador. Você verá a seguinte página inicial:

      Página inicial do App Sidekiq

      Clique no botão Which Sharks Are in Danger? [Quais tubarões estão em perigo?] . Como não fez upload de nenhum tubarão ameaçado de extinção, isso levará você até a visualização de endangered index:

      Exibição do índice Endangered [Em perigo]

      Clique em Import Endangered Sharks para importar os tubarões. Você verá uma mensagem de status informando que os tubarões foram importados:

      Iniciar importação

      Você verá também o início da importação. Atualize sua página para ver a tabela inteira:

      Atualizar tabela

      Graças ao Sidekiq, o upload de nosso lote grande de tubarões em perigo foi bem-sucedido, sem bloquear o navegador ou interferir com outras funcionalidades do aplicativo.

      Clique no botão Home, no final da página, para voltar à página principal do aplicativo:

      Página inicial do App Sidekiq

      A partir daqui, clique em Which Sharks Are in Danger? novamente. Isso levará você diretamente para a visualização de data, uma vez que você já fez o upload dos tubarões.

      Para testar a funcionalidade de exclusão, clique no botão Delete Endangered Sharks​​​ abaixo da tabela. Você deve ser redirecionado para a página inicial do aplicativo novamente. Clicando em Which Sharks Are in Danger? uma última vez levará você de volta para a visualização do index, onde terá a opção de fazer o upload dos tubarões novamente:

      Exibição do índice Endangered [Em perigo]

      Seu aplicativo agora está funcionando com os trabalhadores Sidekiq, que estão prontos para processar trabalhos e garantir que os usuários tenham uma boa experiência ao trabalhar com seu aplicativo.

      Conclusão

      Agora, você tem um aplicativo Rails em funcionamento com o Sidekiq habilitado, o que permitirá que você descarregue operações dispendiosas em uma fila de trabalho gerenciada pelo Sidekiq e apoiada pelo Redis. Isso permitirá que você melhore a velocidade e a funcionalidade do seu site à medida que desenvolve.

      Caso queira aprender mais sobre o Sidekiq, os docs são um bom lugar para começar.

      Para aprender mais sobre o Redis, confira nossa biblioteca dos recursos do Redis. Você também pode aprender mais sobre a execução de um cluster gerenciado do Redis na DigitalOcean, conferindo a documentação do produto.



      Source link