Reapresentando o Hello World para faastRuby - A Plataforma Serverless para Ruby e Crystal - Parte II.
Tags: ruby, crystal, faastruby, serverless
Published: 2019-03-30 18:39:43

---
title: Reapresentando o Hello World para faastRuby - A Plataforma Serverless para Ruby e Crystal - Parte II. 
published: true
description: 
tags: ruby, crystal, faastruby, serverless
---

![alt text](https://faastruby.io/wp-content/uploads/2019/03/logo-negative-1.png "faastRuby logo")

Olá amigos developers! Esta é a segunda parte do artigo. Se você quer saber conceitos básicos sobre faastRuby ou ainda não se cadastrou na plataforma comece por aqui [Parte I](https://dev.to/sergiosouzalima/reapresentando-o-hello-world-para-faastruby-a-plataforma-serverless-para-ruby-e-crystal-parte-i-ac0).

O que vamos criar?
Usando os comandos e a plataforma serverless [faastRuby](https://www.faastruby.io), vamos criar uma function em Ruby e disponibilizá-la rapidamente na internet.

## Passo a Passo da Criação do Projeto

### Login

Entre na pasta que criamos anteriormente.

```Bash
$ cd faastruby
$ faastruby/> 
```

Faça o login com a conta criada na [Parte I](https://dev.to/sergiosouzalima/reapresentando-o-hello-world-para-faastruby-a-plataforma-serverless-para-ruby-e-crystal-parte-i-ac0) deste artigo.

```Bash
$ faastruby/>faastruby login       
Email: you@your-email.com
Password: ********
Login successful.
```

### Criando o Projeto Hello World

Agora vamos criar o projeto Hello World propriamente dito.


```Bash
$ faastruby/>faastruby new-project hello-world --api
```

O comando *faastruby new-project* irá criar a pasta *hello-world* com as subpastas, arquivos estáticos e functions iniciais. Você verá a mensagem abaixo

```Bash
+ d ./hello-world
+ f ./hello-world/project.yml
+ f ./hello-world/secrets.yml
+ d ./hello-world/functions/root
+ f ./hello-world/functions/root/handler.rb
+ f ./hello-world/functions/root/faastruby.yml
+ d ./hello-world/functions/catch-all
+ f ./hello-world/functions/catch-all/handler.rb
+ f ./hello-world/functions/catch-all/faastruby.yml
+ d ./hello-world/public
+ f ./hello-world/public/faastruby.yml
+ f ./hello-world/.gitignore
Initialized empty Git repository in /Users/you/workspace/faastruby/hello-world/.git/
Project 'hello-world' initialized.
Now run:
$ cd hello-world
$ faastruby local

Then visit http://localhost:3000
```
Entre na pasta *hello-world* que acabamos de criar.

```Bash
$ faastruby/> cd hello-world
$ faastruby/hello-world/>
```
### Significado de Pastas e Arquivos

```Bash
├── functions <---------------- Todas functions ficam dentro desta pasta
│   ├── catch-all <------------ Se uma function não é encontrada, esta function é executada.
│   │   ├── faastruby.yml
│   │   └── handler.rb
│   └── root <----------------- Requisições em "root path" '/' caem aqui.
│       ├── faastruby.yml <---- Configuração de arquivos estáticos.
│       └── handler.rb
├── project.yml <-------------- Arquivo de configuração do projeto.
├── public <------------------- Aqui dentro ficam arquivos estáticos.
│   └── faastruby.yml
└── secrets.yml <-------------- Seus secrets ficam aqui.
```
Subindo o Servidor Local
Agora vamos subir o servidor local e verificar se nosso projeto está funcionando.

```Bash
$ faastruby/hello-world/> faastruby local
```

Você verá a mensagem

```Bash
Puma starting in single mode...
* Version 3.12.1 (ruby 2.6.0-p0), codename: Llamas in Pajamas
* Min threads: 0, max threads: 32
* Environment: production
* Listening on tcp://0.0.0.0:3000
Use Ctrl-C to stop
2019-03-23 16:21:23 -0300 | Detecting existing functions.
---
2019-03-23 16:21:23 -0300 | Ruby functions: ["root", "catch-all"]
---
2019-03-23 16:21:23 -0300 | Crystal functions: []
---
2019-03-23 16:21:23 -0300 | Listening for changes.
---
2019-03-23 16:21:23 -0300 | faastRuby Local is ready at http://localhost:3000
```
Em seguida visite o endereço: [http://localhost:3000]()

Se tudo está funcionando bem até aqui, você verá o resultado da function *root* em seu browser.

```javascript
{
"message": "Welcome to FaaStRuby Local! Edit the function 'root' to customize this response."
}
``` 
### Criando Sua Primeira Function
Sua primeira function será chamada *hello* e ela responderá no formato json com a mensagem "Hello, World!".

**Importante**: para criar functions, você deve estar dentro da pasta *functions* de seu projeto.

```Bash
$ faastruby/hello-world/> cd functions
$ faastruby/hello-world/functions/>
```

Use o comando *faastruby new hello* para criar a function *hello*. 

```Bash
$ faastruby/hello-world/functions> faastruby new hello
```

```Bash
+ d hello
+ d hello/spec
+ f hello/spec/spec_helper.rb
+ f hello/spec/handler_spec.rb
+ f hello/README.md
+ f hello/Gemfile
+ f hello/handler.rb
+ f hello/faastruby.yml
✔ Installing gems...
```

O comando *faastruby new* criou pastas e arquivos iniciais específicas para sua function *hello*.
Vamos entrar dentro da pasta *hello* para implementarmos nossa solução em Ruby.

```Bash
$ faastruby/hello-world/functions/> cd hello
$ faastruby/hello-world/functions/hello/>
```

Faça sua function *hello* ficar assim:

```ruby
# hello-world/functions/hello/handler.rb
require 'json'

def handler event
  render json: { 'message' => 'Hello, World!' }
end
```

Temos que ajustar o teste unitário:

```ruby
# hello-world/functions/hello/spec/handler_spec.rb
require 'spec_helper'
require 'handler'
require 'json'

describe '#handler' do
  let(:body) { handler(event).body }
  let(:event) {
    Event.new(
      body: nil, query_params: {},
      headers: {}, context: nil
    )
  }

  context 'when function is requested' do
    let(:response_value) {
      JSON.parse(body).values.first
    }
    it 'returns a String' do
      expect(body).to be_a(String)
    end
    it "returns 'Hello, World!'" do
      expect(response_value).to eq('Hello, World!')
    end
  end
end
```

Agora precisamos incluir uma gem no arquivo Gemfile desta function. Estamos usando a gem *json* dentro da function *hello*, portanto precisamos inclui-la no Gemfile.


```ruby
# hello-world/functions/hello/Gemfile
source 'https://rubygems.org'

gem 'json'

group :test do
  gem 'rspec'
  gem 'faastruby-rpc'
  gem 'faastruby'
end
``` 

Não esqueça do *bundle install*

```Bash
$ faastruby/hello-world/functions/hello/> bundle install
```

Nossos testes estão passando?

```Bash
faastruby/hello-world/functions/hello/> rspec -fd
```

```Bash
handler
  when function is requested
    returns 'Hello, World!'
    returns a String

Finished in 3.89 seconds (files took 0.6736 seconds to load)
2 examples, 0 failures
```

Subindo o Servidor Local, Novamente

Lembre-se sempre que para subir o servidor local o comando *faastruby local* deverá ser usado na pasta principal do projeto.

Portanto vá para a pasta raiz do projeto, *hello-world* e suba o servidor.


```Bash
$ faastruby/hello-world/> faastruby local
```

Vamos ver o funcionamento da nossa function *hello*.

Visite o endereço: [http://localhost:3000/hello]()

Você verá o resultado da function *hello* em seu browser.

```javascript
{
"message": "Hello, World!"
}
``` 

### O Primeiro Deploy

Quando executamos o deploy do projeto para a plataforma faastRuby, as functions e arquivos estáticos vão para o Workspace.

Para fazer o deploy do projeto o comando *faastruby deploy* deverá ser usado na pasta principal do projeto.

Portanto certifique-se que você está na pasta *hello-world* e execute o deploy.


```Bash
$ faastruby/hello-world/> faastruby deploy
```

```Bash
┌ Deploying project 'hello-world' to workspace 'hello-world-stage-8f6999'
├── [✔] Connecting to workspace 'hello-world-stage-999999'
├── [✔] Uploading static assets in 'public'
├── [✔] Deploying function from 'functions/hello'
├── [✔] Deploying function from 'functions/catch-all'
└── [✔] Deploying function from 'functions/root'
* Project URL: https://hello-world-stage-999999.tor1.faast.cloud
```

Finalmente, sua function está disponível na nuvem! A sua URL será parecida com a URL a seguir.

Visite o endereço no seu browser: [https://hello-world-stage-999999.tor1.faast.cloud/hello]()

Você verá o resultado da function *hello* em seu browser.

```javascript
{
"message": "Hello, World!"
}
``` 

## Conclusão

* Neste artigo aprendemos como construir um projeto em faastRuby do zero e enviar para a nuvem.
* Aprendemos como criar uma function própria, criar testes unitários e executar a function com o servidor local.


Espero que tenham gostado do artigo!