DEV Community: Augusto Queirantes

Tudo que você precisa saber sobre DynamoDB - Introdução

Augusto Queirantes — Wed, 03 Jan 2024 02:10:04 +0000

O que é DynamoDB

DynamoDB é um banco de dados não relacional totalmente gerenciado pela AWS. Isso significa que, você não precisará ter preocupações relacionadas à escalabilidade e disponibilidade do seu banco de dados. A AWS assume a responsabilidade por esses aspectos, permitindo que você se concentre exclusivamente nas necessidades específicas do seu sistema.

Conceitos básicos

O DynamoDB armazena dados em uma estrutura de documentos, que são salvos como JSON, proporcionando flexibilidade na adição de novos campos conforme necessário.

Para indexar os registros, o DynamoDB utiliza uma combinação de partition_key e sort_key. A partition_key define um atributo usado para separar itens, agrupando itens com a mesma chave de partição. Essa chave também é conhecida como primary_key ou HASH. Já a sort_key é um atributo opcional usado para ordenar itens que compartilham a mesma chave de partição, também chamada de RANGE ou range key.

Consistência de leitura

O DynamoDB armazena três réplicas da sua base de dados em regiões geograficamente distintas. Para garantir que, ao realizar uma leitura, você obtenha a versão mais atual dos dados, o DynamoDB oferece dois níveis de consistência de leitura: consistência eventual e consistência forte.

Operações realizadas com consistência eventual permitem que consultas retornem dados que ainda não foram totalmente propagados para todas as regiões; em contrapartida, esse modo oferece uma latência menor. Por outro lado, operações realizadas sob o regime de consistência forte garantem que os dados lidos sejam os mesmos em todas as regiões, embora a latência dessas operações seja maior.

A escolha entre esses níveis de consistência é muito importante e deve ser feita levando em consideração as especificidades da sua aplicação.

Conclusão

Em resumo, o DynamoDB destaca-se como uma ótima ferramenta que resolve muito bem os problemas que se propõe.

Nos próximos artigos, continuaremos desbravando as fascinantes possibilidades que o DynamoDB proporciona.

Agradeço por fazer parte desta jornada. Até o próximo artigo!

Learning GO - Creating the server - Part 2

Augusto Queirantes — Thu, 13 Oct 2022 14:35:03 +0000

Hey guys! How are you? Hope everyone is ok!

This is the second part of a series of articles that will document my process of learning Go. In the past article we created a working environment and executed a hello world. In this article we'll configure a web server to see it working in a browser.

Table of content

Go package managers
Configuring the webserver
Creating the routes
Creating the controllers -- sad

Go package managers

A package manager is a way to versionate the dependencies you want inside your application, that's the same as rails gems or npm packages.

To configure it we gonna execute the following commands inside the docker container:

go mod init
go mod init github.com/your_user/your_repo

You can execute any of the above commands, the difference is the module name, if you set your github repo as an argument this will be the module name, otherwise the module name will be app

After run the command you should see somehting like this as output:

Configuring the webserver

To create the webserver we gonna use a lib called gin, that's how we gonna configure it:

The first thing to do is download the lib, to do this we gonna execute the following command:

go get -u github.com/gin-gonic/gin

Once it's installed we need to import it on our main file, that's how it should looks like in the end of the day:

package main

import (
  "net/http"
  "github.com/gin-gonic/gin"
)

func main() {
  webserver := gin.Default()

  webserver.GET("/", func(context *gin.Context) {
    context.JSON(http.StatusOK, gin.H{
      "message": "Hello, world!",
    })
  })

  webserver.Run(":3000")
}

You probably noticed that we had some changes in this file, they were:

Change imports

We didnt's needed to import fmt package anymore cause we don't wanna the print function, so we removed it. Now we just import gin and net/http

Refactor on main function

We completly refactored the main function, now it creates a webserver that has only one route that responds with a json. After creating this webserver we run this server on port 3000

If everything is ok you should see something like this when you access this route:

Creating the routes

You may noticed that we have only one route on our application, that's a problem because I want to have as many routes as I can inside of a separeted file. To do this we gonna follow this proccess:

The first thing to do is create a file called server.go inside config folder, this file will contain our routes and execute them, that how it should look:

package config

import (
  "github.com/gin-gonic/gin"

  "github.com/your_user/your_repo/controllers"
)

func Server() {
  router := gin.Default()

  router.GET("/", controllers.HomeIndex)
  router.GET("/message/:message", controllers.ShowMessage)

  router.Run(":3000")
}

This code imports gin and controllers (we'll talk about it soon) and has only one method, called Server, this method contains all routes and execute them in the end of the method, that's pretty much the same code that we have in our main.

You may noticed that when we create a route we gives the route's path as first argument and call a method as second argument, this method is instantiated in a controller and will everything we want this route to do.

For test purposes we'll create two routes, / and /message. The / route will always return Hello world and /message route will return a string that's given as parameter in the path.

Creating the controllers

To respond to a route we'll use a controller, to create the controllers we'll need in this example follow this steps:

We'll need to create two files, controllers/homeController.go and controllerrs/messageController.go

The home controller will have the following code:

package controllers

import (
  "net/http"
  "github.com/gin-gonic/gin"
)

func HomeIndex(context *gin.Context) {
  context.JSON(http.StatusOK, gin.H{"message": "Hello World!"})
}

This code just returns a json with the expected message, that's the same code we have in our main right now

The message controller will have the following code:

package controllers

import (
  "net/http"
  "github.com/gin-gonic/gin"
)

func ShowMessage(context *gin.Context) {
  message := context.Param("message")

  context.JSON(http.StatusOK, gin.H{"message": message})
}

This code has the same structure with only one addition, it gets a params from the url and return it in the json.

Now we just need to change our main file to get everything working together, that's how it should looks like:

package main

import (
  "github.com/your_user/your_repo/config"
)

func main() {
  config.Server()
}

The changes we made now is to import only the config folder and call the Server method we created before.

If everything is ok you should see something like this when execute go run main.go:

If you access home

If you access message

Notice that the API returns test cause that's the argument we're giving, you can test it and see the result changing.

We'll guys, that's it! If there is any questions leave a comment! You can find the full code here

Learning GO - Creating the environment using docker - Part 1

Augusto Queirantes — Wed, 12 Oct 2022 08:24:53 +0000

Hey guys! How are you? Hope everyone is ok!

I'm a Rails developer that wants to learn Go and document the process on this series of articles. It's worth mentioning that I'm learning this technology, so, suggestions are welcome :)

In this article I'll setup docker and test it with a hello world!

Table of Content

Setting up Docker
Creating hello world
Creating Github repository

Setting up Docker

The first thing we need to do is create a folder to the repo, you can use the command bellow to create the folder and go to that directory:

mkdir learning_go
cd learning_go

This command will create a new folder called learning_go. All changes we gonna do will be in this folder.

Once the folder is created we need to create two files: Dockerfile and docker-compose.yml. You can use the following command to create this file:

touch Dockerfile
touch docker-compose.yml

Once the file is created you'll need to open the folder inside your favorite text editor.

The Dockerfile content will be the following:

FROM golang:1.19.2-alpine3.16

That's the only line you'll gonna need on this file. It tells docker to download a image that is built based on alpine linux and runs go version 1.19.2.

Now we need to edit docker-compose.yml, that's the file content:

version: '3.9'

services:
  learning_go:
    container_name: learning_go
    build: .
    volumes:
      - ./:/go/src/app
    ports:
      - "3000:3000"
    working_dir: /go/src/app
    tty: true

Once everything is done you need to run the following command:

docker-compose up -d

If everything is ok you should see something like this:

If you want to execute commands inside the docker container you must run the following command:

docker exec -it learning_go sh

Creating hello world

Now that docker is running as expected we need to create a go file to test it, so we gonna create a file called main.go in the root path of the application and set this content:

package main

import "fmt"

func main() {
    fmt.Println("hello world!")
}

This code is only a basic hello world example. To execute this code you need to run the following command inside the docker container:

go run main.go

You should see the following output:

Creating Github repository

Now that everything is working we need to store the code in a github repository. To do so you just need to access this url and set the repo name such as the image bellow

Once it's done you just need to follow the instruction that github provides:

Conclusion

Well guys, that's it! Thanks for your attention! Let me know if there is any questions that I can help. You can find this project repository here

Rails guide - Project patterns - Part 6

Augusto Queirantes — Sun, 09 Oct 2022 07:02:54 +0000

Hey guys! How are you?

This article is a part of a series that will teach how to create a production ready rails application. In this article we gonna talk about project patterns and how we'll organize our project.

Table of content

Rails way to do things
Project patterns
Project tree
Conclusion

Rails way to do things

Rails is a framework known by their conventions, you can find the following quote in Rails official documentation

Rails is opinionated software. It makes the assumption that there is a "best" way to do things, and it's designed to encourage that way - and in some cases to discourage alternatives. If you learn "The Rails Way" you'll probably discover a tremendous increase in productivity. If you persist in bringing old habits from other languages to your Rails development, and trying to use patterns you learned elsewhere, you may have a less happy experience.

This quote clearly says that we need to organize our software in a way that respects Rails standards, so, that's how we gonna do this:

Project patterns

We gonna organize our software following these principles:

Controllers will have no logic, it'll either validate parameters or call another class
Services will interact with thirdy party services
UseCases will create data into our database and interact with our models
Models will store application logic

If you already read about Clean Architecture probably noticed that the project structure follows the ideia that pattern suggests.

Folder organization

In the end of the day, we'll use mostly the following folders in our project:

- app
-- controllers
-- models
-- services
-- use_cases
- lib

The controller folder is our interface to the web, that's where we'll define our routes actions.

The models folder is where we define our entities and some business logic.

The services folder is our interface to third party applications, such as external apis.

The use_cases folder is our interface to our entities.

The lib folder will contain all code that's not directly related to our project core, such as parsers.

Conclusion

I hope everyone understood why we gonna organize the project using this method, please comment if there is any questions.

Rails guide - Adding CI - Part 5

Augusto Queirantes — Sun, 25 Sep 2022 02:15:50 +0000

Hey guys! How are you?

This article is a part of a series that will teach how to create a production ready rails application. Today we're gonna talk about CI.

Table of content

What is CI
Tooling
Action creation

What is CI

CI, ou integração contínua, é uma metodologia que visa automatizar o processo de execução de testes e linting para cada alteração de código feita, garantindo assim mais qualidade e segurança no processo

CI, or continuous integration, is a methodology that automates linting and tests execution after each pull request ensuring quality and security in the process.

Tooling

The tool we'll use to solve this problem is [Github actions[(https://github.com/features/actions). This tool allow us to automate the tests and linting execution after any commit on a pull request.

Action creation

To create the github action we gonna work on .github/workflows path, all files related to a action goes here.

First thing to do is create a file called linter.yml with the following content:

name: Linter

on: push

jobs:
  linting:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v1
      - uses: actions/setup-ruby@v1
      - name: Install dependencies
        run: bundle install
      - name: Run linter
        run: rubocop

This file will create a action called Linter that have on job called linting, this job will be executed in a ubuntu doker image that will perform the following steps:

Pull the most recent code
Install ruby on the image
Install system dependencies
Install gems
Execute linter

Now that linter is configured we gonna create a file called tests.yml to configure tests action, here the file content:

name: Tests

on: push

jobs:
  specs:
    runs-on: ubuntu-latest

    services:
      postgres:
        image: postgres
        env:
          POSTGRES_USER: user
          POSTGRES_PASSWORD: 123456
        options: >-
          --health-cmd pg_isready
          --health-interval 10s
          --health-timeout 5s
          --health-retries 5
        ports:
          - 5432:5432

    steps:
      - uses: actions/checkout@v1

      - uses: actions/setup-ruby@v1
        with:
          bundler-cache: true

      - name: Install dependencies
        run: sudo apt-get install libpq-dev

      - name: Install dependencies
        run: |
          sudo apt-get -yqq install libpq-dev
          gem install bundler
          bundle install --jobs 4 --retry 3

      - name: Database setup
        run: |
          bundle exec rake db:create
          bundle exec rake db:migrate
        env:
          RAILS_ENV: test
          POSTGRES_USER: user
          POSTGRES_PASSWORD: 123456

      - name: Run specs
        run: bundle exec rspec

This file will create a job called Tests that will create a job called specs, this job will be executed using a ubuntu docker image as base and perform the following steps:

Setup postgres database
Pull the most recent code
Setup ruby
Install dependencies
Create database
Run specs

If everything is ok you should look something like this whey you open a pull request on github:

You can see all code changes here

Rails guide - Adding tests - Part 4

Augusto Queirantes — Fri, 23 Sep 2022 02:54:19 +0000

Hey guys! How are you?

This article is a part of a series that will teach how to create a production ready rails application. Today we're gonna talk about testing with rspec.

Table of content

What is Rspec
Setting up environment
Configuring Rspec
Test it out

What is Rspec

Rspec is a ruby gem that allow us to test our applications, it provides the best way to do TDD while developing new features.

Setting up environment

We need to follow those instructions to get rspec working:

Install the gems

group :test do
  # Rspec
  gem "rspec-rails", "~> 5.1.2"

  # Fake data generator
  gem "faker", "~> 2.23.0"

  # Clean database before each test execution
  gem "database_cleaner-active_record", "~> 2.0.1"

  # Factories
  gem "factory_bot_rails", "~> 6.2.0"

  # Models specs
  gem "shoulda-matchers", "~> 5.1.0"
end

Download the dependencies

bundle install

Generate Rspec configuration files

rails generate rspec:install

Require rails helper

To properly run specs we need to require rails helper on top of each spec file, to prevent this we can create a file called .rspec in the root path of the application and put the following content there:

--require rails_helper

Configuring Rspec

Now that we have all the setup done we need to properly configure rspec, to do so we need to edit rails_helper and spec_helper. You'll find the full code snippet in a pull request in the end of the article, nut here's a quick explanation of some important points:

Rails Helper

This file stores all rspec general configuration and some dependencies configurations such as factory_bot and shoulda_matchers. Another important thing is that on the top of the file we have a guard clause that prevents rspec to run in a environemnt different thant test, you should never remove this safe guard

Spec Helper

This file is simpler, it contains only some inclusions and basic setup, rails_helper requires this file to improve it configuration

Test it out

Now that everything should be ok lets test it out. To do so we need to create a spec file and verify if it's passing.

Create a file under the spec folder called test_spec.rb and put the following content there:

RSpec.describe do
  describe "rspec setup" do
    it "returns true" do
      expect(true).to be(true)
    end
  end
end

Now all you need to do is run rspec using this command:

rspec

You should look something like this if everything is ok:

You can either specify somethings to this command such as the file and line it should execute, here's an example:

rspec spec/test_spec.rb
rspec spec/test_spec.rb:3

You can see all the code changed here

Rails guide - Adding linter - Part 3

Augusto Queirantes — Sat, 17 Sep 2022 22:06:48 +0000

Hey guys! How are you!

That's the third article of a series that teaches how to create a production ready Rails application. In this article we'll configure linter.

Linter is a tool that assures that all code follows the best practices defined in the project. The tool that we gonna use is called rubocop.

Configurin rubocop

First thing to do is add this gem to the application gemfile, to do so just add the following line in your Gemfile:

gem "rubocop", "~> 1.36.0", require: false
gem "rubocop-rails", "~> 2.16.1", require: false
gem "rubocop-rspec", "~> 2.13.1", require: false

This lines will install rubocop that's the main gem we'll use and rubocop-rails and rubocop-rspec that are dependencies of the main gem. Once you save the file, run the following command to install them:

bundle install

Now we need to create rubocop's configuration file, it's called .rubocop.yml and need to be at the root path of the application, here it's content:

require:
  - rubocop-rspec
  - rubocop-rails

AllCops:
  NewCops: enable
  Exclude:
    - 'app/assets/**/*'
    - 'app/views/**/*'
    - 'db/**/*.rb'
    - 'lib/**/*.rake'
    - 'config/**/*.rb'
    - 'bin/bundle'

You can use this file to ignore some checks that you don't wanna run in your application, you can see how to do it by looking in the pull request in the end of this article.

Testing it out

Now that the tool is properly configured, let's test it. To run rubocop just type the following command in your terminal:

rubocop

If everything is ok you should look something like this:

That's a lot of errors, but it's ok, to fix most of them you can run the following command:

rubocop -A

It'll fixes all correctable issues, now just fix the rest and everything is fine

You can see all the code changed here

Rails guide - Adding Docker - Part 2

Augusto Queirantes — Sat, 17 Sep 2022 05:56:39 +0000

Hey guys! How are you!

That's the second article of a series that teaches how to create a production ready Rails application. In this article we'll configure docker and docker compose.

Configuring docker

First thing we need to do is create a file called Dockerfile in the root path of the application.

The following snippet contains the file content:

FROM ruby:3.1.2-alpine3.16

RUN apk --update add postgresql-dev postgresql-client build-base tzdata libxslt-dev libxml2-dev

RUN mkdir /app

WORKDIR /app

This file creates a image that contains everything the application needs to run. To create this image docker follow this steps:

FROM ruby:3.1.2-alpine3.16

This line specifies that docker should download the following image from dockerhub and use it as base to run the following commands

RUN apk --update add postgresql-dev postgresql-client build-base tzdata libxslt-dev libxml2-dev

This instruction tells to docker install the following dependencies:

build-base: To ensure certain gems can be compiled
tzdata: Handle timezones
libxslt-dev libxml2-dev: Nokogiri native dependencies
postgresql-dev postgresql-client: Postgres related

RUN mkdir /app

Creates a folder called "/app"

WORKDIR /app

Tells docker that the folder "/path" is the main folder of the application.

Configuring docker compose

The first thing to do to configure docker-compose is create a file called docker-compose.yml in the root path of the application. This file should have the following content:

version: '3.9'

services:
  postgres:
    image: postgres:14.5-alpine
    environment:
      POSTGRES_USER: user
      POSTGRES_PASSWORD: 123456
      PGDATA: /data/postgres
    volumes:
      - postgres:/data/postgres
    ports:
      - "5432:5432"
    networks:
      - postgres

  rails_guide:
    build: .
    volumes:
      - .:/app
    image: rails_guide
    container_name: rails_guide
    tty: true
    ports:
      - "3000:3000"
    environment:
      - DATABASE_NAME=app_development
      - DATABASE_USERNAME=user
      - DATABASE_PASSWORD=123456
      - DATABASE_HOST=postgres
    depends_on:
      - postgres
    networks:
      - postgres

networks:
  postgres:
    driver: bridge

volumes:
  postgres:

Executing docker

Now that everything is configured run the following command to create the containers:

docker-compose up -d

This command will create both containers and get it running

You can verify if everything is ok by running the following commando

docker ps

The output should looks like this:

Now run this command to go inside the container:

docker exec -it rails_guide sh

Setting up the database

You'll need to update the database configuration to mathces the docker environment, you'll need to change config/database.yml with the following content:

default: &default
  adapter: postgresql
  encoding: unicode
  pool: <%= ENV.fetch("RAILS_MAX_THREADS") { 5 } %>
  host: <%= ENV.fetch("DATABASE_HOST", "localhost") %>
  user: <%= ENV.fetch("DATABASE_USERNAME", "user") %>
  password: <%= ENV.fetch("DATABASE_PASSWORD", "123456") %>

development:
  <<: *default
  database: app_development

test:
  <<: *default
  database: app_test

production:
  <<: *default
  database: <%= ENV.fetch("DATABASE_NAME", "app_production") %>

To setup the database you'll need to run the following commands:

rails db:drop
rails db:create
rails db:migrate

Running the server

You can verify if everything is ok by starting the server by running the following command:

rails s -b 0.0.0.0

If everything is ok you'll see something like this:

You can see all code changes here

Rails guide - Creating the app - Part 1

Augusto Queirantes — Sat, 20 Aug 2022 23:34:41 +0000

Hey guys! How are you?

That's the first article of a series that'll teach how to create a production ready Rails application. In this article we'll install Ruby, Rails and create the application.

Installing dependencies

The first thing to do is install Ruby and Rails, to do that we'll use a tool called RVM, it's used to install and manage different versions of Ruby.

Execute the command bellow to install Ruby and Rails latest versions:

\curl -sSL https://get.rvm.io | bash -s stable --rails

You can verify if everything is ok running this two commands:

ruby --version
rails --version

The output should look like this:

Creating the project

Run the following command to create the application:

rails new rails_application --api --adapter=postgresql

Now that the application is created we need to go to its directory using this command:

cd rails_application

Testing it out

The next step is test the application, to do so you'll need to run the server using the above command:

rails s

If everything is ok you should be able to see somehting like this when you access http://localhost:3000

That's it, guys! See you soon in the next part. You can find the code here