Forem: Rafael Firmino

open policy agente

Rafael Firmino — Sat, 06 Sep 2025 00:06:57 +0000

Go Development Has Never Been So Fast: Discover How Tilt Changes Everything!

Rafael Firmino — Sat, 03 May 2025 02:53:26 +0000

Application development can be a challenging process, especially when it comes to complex environments and multiple services. For Go developers, finding ways to accelerate the workflow without compromising quality is a priority. Fortunately, tools like Tilt arise to transform this reality. This article will explore how Tilt can boost your Go development process, making it more agile and efficient.

What is Tilt?
Tilt is a development tool that facilitates the automation and integration of microservices workflows. It allows you to have a unified view of your development environment, providing agility to compile, test, and deploy applications quickly and dynamically.

Although it is more commonly associated with Kubernetes environments, Tilt can also be a powerful tool to speed up Go application development. It allows you to configure and observe changes in real-time, automatically updating your environment.

How Does Tilt Accelerate Go Development?

Automatic Compilation and Deployment
Tilt eliminates the manual process of compiling and deploying code. Instead of executing several commands repeatedly, the tool watches for changes in files and performs compilation and deployment automatically. For Go developers, this means less time spent in the build cycle and more time focusing on the more important tasks.
Integration with Kubernetes and Docker
Tilt integrates seamlessly with Kubernetes and Docker, which makes it easier to run containers and services in local development environments. For those already working with containers in Go, Tilt offers a simplified way to configure and monitor services, optimizing the development workflow.
Real-Time Updates
With Tilt, whenever you make any modification to the code, it automatically detects these changes and applies them to the environment in real-time. This allows developers to immediately see the impact of their changes, without needing to restart the entire process manually. This significantly reduces the time between coding and verification.
Full Visibility and Control
Tilt provides an interactive interface that gives you a complete view of services, logs, and container status. This is especially useful in more complex environments where multiple services are running. You have full control over what’s happening, which helps to identify problems faster and optimize development.

How to Configure Tilt for a Go Project?
Here’s a simple step-by-step guide to integrate Tilt into your Go project:

Step 1: Install Tilt
First, you need to install Tilt. In the terminal, use the following command (for Linux systems):

Step 2: Tiltfile Configuration
In the root directory of your Go project, create a file called Tiltfile. This file will contain the configuration needed for Tilt to identify and monitor your code.

Basic example of Tiltfile configuration for Go: This command generates mock files from mockery every time a file within the ./internal/port folder is changed.

local_resource(
    name='mock update',
    labels=['test'],
    cmd='mockery',
    deps=['./internal/port'],
    ignore=['./internal/port/mock_*.go'],
)

We can also add a button with actions if you want to perform some actions manually:

load('ext://uibutton', 'cmd_button') //extension can be imported

local_resource(
    name='Run tests',
    labels=['test'],
    cmd='go test ./...',
    auto_init=False,
)
cmd_button('Run_tests',
    argv=['sh', '-c', 'go test ./...'], //command to be executed
    resource='Run tests', //the value here needs to be the same as the name of the local_resource
    icon_name='play_arrow', //we can use material design icons here
    text='Run tests', // button tooltip
)

Use Cases: Tilt in Action Here are some examples of how Tilt can be useful in different Go development scenarios:

Microservices Development: For those working with a microservices architecture, Tilt simplifies the management of multiple containers and services. It allows you to quickly change a service and see the results in real-time, without interrupting the entire infrastructure.

Testing Environments: By automating the build and deploy cycle, Tilt helps quickly set up testing environments to ensure your Go code works as expected.

Continuous Integration: Tilt can easily be integrated with CI/CD systems to speed up the code integration and deployment process.

Conclusion if you are a Go developer and are looking for ways to make your workflow more agile, Tilt is the tool that can transform your development approach. With the automation of the build cycle, deployment, and change monitoring, Tilt lets you focus on what truly matters: writing high-quality code.

Try Tilt and see how it can accelerate your Go development, taking your productivity to a new level!

Send email with GO + AWS SES for multiple recipents and many attached files

Rafael Firmino — Thu, 15 Jun 2023 02:02:12 +0000

This is a simple example how send email for many recipients and add many attachments using SES

package main

import (
    "fmt"
    "log"
    "strings"

    "github.com/aws/aws-sdk-go/aws"
    "github.com/aws/aws-sdk-go/aws/session"
    "github.com/aws/aws-sdk-go/service/ses"
)

type EmailData struct {
    From      string
    Recipient Recipient
    Subject   string
    Body      string
    Attachs   map[string][]byte
}

type Recipient struct {
    To  []string
    Cc  []string
    Bcc []string
}

func main() {
    sesClient, err := getSesClient()
    if err != nil {
        fmt.Println(err)
    }

    emailData := EmailData{
        From: "teste@example.com.br",
        Recipient: Recipient{
            To:  []string{"teste2@example.com.br"},
            Cc:  []string{"teste2@example.com.br", "teste3@example.com.br"},
            Bcc: []string{"teste4@example.com.br"},
        },
        Subject: "Subject Example",
        Body:    "Body Example",
        Attachs: map[string][]byte{
            "file1": []byte("attach1"),
            "file2": []byte("attach2"),
            "file3": []byte("attach3"),
            "file4": []byte("attach4"),
        },
    }
    _, err = sesClient.SendRawEmail(emailData.MountEmail())
    if err != nil {
        log.Fatal("error for send email:", err)
    }

}

func (e *EmailData) MountEmail() *ses.SendRawEmailInput {
    header := fmt.Sprintf("From: %s\r\n", e.From)
    header += fmt.Sprintf("To: %s\r\n", strings.Join(e.Recipient.To, ", "))
    header += fmt.Sprintf("Cc: %s\r\n", strings.Join(e.Recipient.Cc, ", "))
    header += fmt.Sprintf("Subject: %s\r\n", strings.Join(e.Recipient.Bcc, ", "))
    header += "MIME-Version: 1.0\r\n"
    header += "Content-Type: multipart/mixed; boundary=\"Boundary\"\r\n\r\n"

    //BodyPart
    bodyPart := fmt.Sprintf("--Boundary\r\n")
    bodyPart += fmt.Sprintf("Content-Type: text/plain; charset=\"UTF-8\"\r\n")
    bodyPart += fmt.Sprintf("Content-Disposition: inline\r\n\r\n")
    bodyPart += fmt.Sprintf("%s\r\n\r\n", e.Body)

    attachmentParts := ""
    for filename, attachment := range e.Attachs {
        attachmentPart := fmt.Sprintf("--Boundary\r\n")
        attachmentPart += fmt.Sprintf("Content-Type: application/octet-stream\r\n")
        attachmentPart += fmt.Sprintf("Content-Disposition: attachment; filename=\"%s\"\r\n\r\n", filename)
        attachmentPart += string(attachment) + "\r\n"
        attachmentParts += attachmentPart
    }

    endPart := fmt.Sprintf("\r\n--Boundary--")
    rawMessage := header + bodyPart + attachmentParts + endPart
    email := &ses.SendRawEmailInput{
        RawMessage: &ses.RawMessage{
            Data: []byte(rawMessage),
        },
    }

    return email
}

func getSesClient() (*ses.SES, error) {
    awsSession, err := session.NewSession(&aws.Config{
        Region: aws.String("us-east-1"),
    })
    if err != nil {
        fmt.Println(err)
        return nil, err
    }
    sesClient := ses.New(awsSession)

    return sesClient, err
}

Aws SAM and Golang.

Rafael Firmino — Tue, 30 Aug 2022 02:32:00 +0000

In the last year, I worked creating lambda functions for many parts of core businesses.
When I started this journey with lambda I looked about the serverless, but the documentation is partitioned in many plugins repositories, because this point I decided to use AWS SAM. We do not have the intention the changing our cloud.
AWS Serverless Application Model is a good tool for creating your lambda and some resources like SQS, SNS, S3, and etc.

Where GO enter?
Go is compiled and your binary contains only the library needed for work very well, this approach creates a small binary.
Go has very fast performance and your memory usage is very low.
Another good point is the pipeline. The pipeline in GO is very smaller and easy to understand and mantein.
Let me show you how easy is create a serverless function using AWS SAM

Link of the repository example

The Golang Function



package main

import (
  "context"
  "os"

  "github.com/aws/aws-lambda-go/lambda"
)


func handler(ctx context.Context) error {
    fmt.Println("hello world" + os.Getenv("AnyParameterYouWant"))
        return nil
}

func main() {
    lambda.Start(handler)
}



# This is the SAM template that represents the architecture of your serverless application
# https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/serverless-sam-template-basics.html

# The AWSTemplateFormatVersion identifies the capabilities of the template
# https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/format-version-structure.html
AWSTemplateFormatVersion: 2010-09-09
Description: >-
    Any description you want
# Transform section specifies one or more macros that AWS CloudFormation uses to process your template
# https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/transform-section-structure.html
Transform:
  - AWS::Serverless-2016-10-31

# Resources declares the AWS resources that you want to include in the stack
# https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/resources-section-structure.html

# More info about Globals: https://github.com/awslabs/serverless-application-model/blob/master/docs/globals.rst
Globals:
  Function:
    Timeout: 200
    Runtime: go1.x
    Environment:
      Variables:
        AnyParameterYouWant: !Ref AnyParameterYouWant #this parameter is injected in all lambdas in this file

Parameters:
  stage:
    Type: String
    Default: homologation
  AnyParameterYouWant:
    Type: String
    Default:  this-stage-is-${stage}

Resources:

  HelloWorldFunction:
    Type: AWS::Serverless::Function
    Properties:
      FunctionName: !Sub helloWorld-${stage}
      PackageType: Zip
      CodeUri: src/main
      Handler: lambda
      Tracing: Active # https://docs.aws.amazon.com/lambda/latest/dg/lambda-x-ray.html
      MemorySize: 1024
      Events:
        Schedule:
          Type: Schedule
          Properties:
            Schedule: 'rate(5 minutes)'
            Name: !Sub HelloWorld-${stage} #this is a name of schedule this approach change by stage name
            Description: HelloWorldFunction
            Enabled: true

  HelloWorldLogGroup:
    Type: AWS::Logs::LogGroup
    Properties:
      LogGroupName: !Sub /aws/lambda/${HelloWorldFunction}
      RetentionInDays: 30
    DependsOn: HelloWorldFunction



name: hello - World
on:
  push:
    branches: [ main ]

jobs:
  build:
    name: hello Wold Build
    runs-on: ubuntu-latest
    defaults:
      run:
        working-directory: go/conciliation
    env:
      ENV_APP: 'HelloWorldTest'
    steps:
      - uses: actions/checkout@v2
      - uses: aws-actions/setup-sam@v1

      - name: aws login
        uses: aws-actions/configure-aws-credentials@v1
        with:
          aws-access-key-id: ${{ secrets.AWS_ACCESS_ID_SAVED_IN_GITHUB_SECRETS }}
          aws-secret-access-key: ${{ secrets.AWS_SECRETS_SAVED_IN_GITHUB_SECRETS }}
          aws-region: 'sa-east-1'

      - name: setup go
        uses: actions/setup-go@v2
        with:
          go-version: '1.19'

      - name: download dependencies
        run: go mod tidy -go=1.19

      - name: Build app with SAM
        run: sam build

      - name: Upaload sam files for S3
        run: |
          sam package --template-file .aws-sam/build/template.yaml \
          --s3-bucket lambda-resources-wieidjdh \
          --output-template-file packaged.yaml
      - name: Deploy sam
        run: |
          sam deploy --template-file packaged.yaml \
          --parameter-overrides \
            Stage=${{ env.ENV_APP }} \
            AnyParameterYouWant="this is value created in pipeline" \
          --stack-name hello-world-${{ env.ENV_APP }} \
          --capabilities CAPABILITY_IAM \
          --no-confirm-changeset

Before running the pipeline you need create the bucket ex: lambda-resources-wieidjdh

Runing Pipeline

Cloudformation stack running after success github actions pipeline finished

The EventBrige has been attached with success in lambda.

CloudWatch Logs Group has been created with retention for 30 days.

Lambda result after running.

Aws SAM and Go is a good choice for create a lambda services very fast in aws.

Thanks.

Enum in Go ?

Rafael Firmino — Fri, 03 Dec 2021 02:52:00 +0000

Golang don't have Enumerators!

I show you the simple way for simulate enum in go.

package domain

type Status uint8

const (
    Creating Status = iota
    Pending
    Expired
    Paid
    Canceled
    Error
    Unknown
)

func (s Status) ToString() string{
    switch s {
    case Creating:
        return "Creating"
    case Pending:
        return "Pending"
    case Expired:
        return "Expired"
    case Paid:
        return "Paid"
    case Canceled:
        return "Canceled"
    }
    return "Unknown"
}

Using:

  statusCanceled := Canceled.ToString()

   // in another package
  statusCanceled := domain.Cenceled.ToString()

The tests:

package domain

import (
    "github.com/stretchr/testify/assert"
    "testing"
)

func TestToString(t *testing.T) {
    type test struct {
        description string
        input       Status
        expected    string
    }

    tests := []test{
        {description: "should return Creating", input: Creating, expected: "Creating"},
        {description: "should return Pending", input: Pending, expected: "Pending"},
        {description: "should return Expired", input: Expired, expected: "Expired"},
        {description: "should return Paid", input: Paid, expected: "Paid"},
        {description: "should return Canceled", input: Canceled, expected: "Canceled"},
        {description: "should return Error", input: Error, expected: "Error"},
        {description: "should return Unknown", input: Unknown, expected: "Unknown"},
    }

    for _, item := range tests {
        t.Run(item.description, func(t *testing.T) {
            assert.Equal(t, item.expected, item.input.ToString())
        })
    }
}

Custom properties in Elastic Search using C# and Serilog

Rafael Firmino — Wed, 24 Nov 2021 23:05:12 +0000

Hi dears!

Today I show you how create a Custom properties for elasticsearch using c# and Serilog.

I Have serilog configuration for send logs to elasticsearch

public class SerilogConfiguration{

    public static void GetFileAndElasticSearchLogger(IConfigurationRoot configuration = null)
      {
          var environment = Environment.GetEnvironmentVariable("ASPNETCORE_ENVIRONMENT");
          configuration ??= new ConfigurationBuilder()
              .AddJsonFile("appsettings.json", optional: false, reloadOnChange: true)
              .AddJsonFile(
                  $"appsettings.{Environment.GetEnvironmentVariable("ASPNETCORE_ENVIRONMENT")}.json",
                  optional: true)
              .AddEnvironmentVariables()
              .Build();

          Log.Logger = new LoggerConfiguration()
              .Enrich.FromLogContext()
              .WriteTo.Debug()
              .WriteTo.Console(
                outputTemplate: "Level:{Level:u4} Tenant:{TenantId} Time:{Timestamp:HH:mm:ss} Message:{Message:lj}{NewLine}{Exception}"
              )
              .WriteTo.Elasticsearch(ConfigureElasticSink(configuration["App:Id"], configuration, environment))
              .Enrich.WithProperty("Environment", environment)
              .ReadFrom.Configuration(configuration)
              .CreateLogger();
      }

      private static ElasticsearchSinkOptions ConfigureElasticSink(string applicationName, IConfigurationRoot configuration, string environment)
      {
          var env = environment?.ToLower().Replace(".", "-");
          if (configuration["ElasticSearch:Password"] != null)
          {
              return new ElasticsearchSinkOptions(new Uri(configuration["ElasticSearch:Uri"]))
              {

                  ModifyConnectionSettings = x => x.BasicAuthentication(
                      configuration["ElasticSearch:User"],
                      configuration["ElasticSearch:Password"]
                  ) ,
                  AutoRegisterTemplate = true,
                  IndexFormat = $"DEV-TO-EXAMPLE-{applicationName}{(env != null? "-"+env : "")}"
              };
          }
          return new ElasticsearchSinkOptions(new Uri(configuration["ElasticSearch:Uri"]))
          {
              AutoRegisterTemplate = true,
              IndexFormat = $"DEV-TO-EXAMPLE-{applicationName}{(env != null? "-"+env : "")}"
          };

      }
    }

Now we need load configuration in startup.cs

public static int Main(string[] args){        { 
SerilogConfiguration.GetFileAndElasticSearchLogger();
...
}

Now we need call a logger methods

var Logger = Serilog.Log.Logger;
Logger
.ForContext("LogName", "Dev.To Example")
.ForContext(ExecutionTime, 1500)
.Information("Created Log....")

Wen this method register the log in elasticsearch the elastic search attach these properties in "fields"

Now we can search log using de KQL

fields.LogName: "%.TO%"
//or 
fields.ExecutionTime > 1500

Pagination using Gorm scopes

Rafael Firmino — Thu, 24 Jun 2021 18:53:29 +0000

Gorm is a fantastic ORM writen in Go for gophers.

Today I will show you how to create pagination using Gorm Scopes.

Scopes allow you to re-use commonly used logic, the shared logic needs to be defined as type

func(*gorm.DB) *gorm.DB

The first step is create a Pagination struct.

//pkg.pagination    
package pkg 
 
type Pagination struct {    
    Limit        int         `json:"limit,omitempty;query:limit"`   
    Page         int         `json:"page,omitempty;query:page"` 
    Sort         string      `json:"sort,omitempty;query:sort"` 
    TotalRows    int64       `json:"total_rows"`    
    TotalPages   int         `json:"total_pages"`   
    Rows         interface{} `json:"rows"`  
}   
 
func (p *Pagination) GetOffset() int {  
    return (p.GetPage() - 1) * p.GetLimit() 
}   
 
func (p *Pagination) GetLimit() int {   
    if p.Limit == 0 {   
        p.Limit = 10    
    }   
    return p.Limit  
}   
 
func (p *Pagination) GetPage() int {    
    if p.Page == 0 {    
        p.Page = 1  
    }   
    return p.Page   
}   
 
func (p *Pagination) GetSort() string { 
    if p.Sort == "" {   
        p.Sort = "Id desc"  
    }   
    return p.Sort   
}

Second step is create a Gorm Scope.

func paginate(value interface{}, pagination *pkg.Pagination, db *gorm.DB) func(db *gorm.DB) *gorm.DB {  
    var totalRows int64 
    db.Model(value).Count(&totalRows)   
 
    pagination.TotalRows = totalRows    
    totalPages := int(math.Ceil(float64(totalRows) / float64(pagination.Limit)))    
    pagination.TotalPages = totalPages  
 
    return func(db *gorm.DB) *gorm.DB { 
        return db.Offset(pagination.GetOffset()).Limit(pagination.GetLimit()).Order(pagination.GetSort())   
    }   
}

The third step is use Gorm scope in your repository.

type CategoryGorm struct {  
    db *gorm.DB 
}   
 
func (cg *CategoryGorm) List(pagination pkg.Pagination) (*pkg.Pagination, error) {  
    var categories []*Category  
 
    cg.db.Scopes(paginate(categories,&pagination, cg.db)).Find(&categories) 
    pagination.Rows = categories    

    return &pagination, nil 
}

Rest Example

I won't talk about how you could implement your handles or access the repository, maybe another time.

The most important thing you need is to return the pkg.pagination for you client.

In a rest application, if I send

http://localhost:3000/categories?limit=10&page=5

Then the output would be:

{   
  "limit": 10,  
  "page": 5,    
  "sort": "Id desc",    
  "total_rows": 41, 
  "total_pages": 5, 
  "rows": [ 
    {   
      "id": "0acd5600-51b9-42e9-9fd0-ff422a6de1d1", 
      "category": "example41"   
    }   
  ] 
}

Golang and Server-Sent Events (SSE)

Rafael Firmino — Wed, 16 Jun 2021 02:14:29 +0000

Server-Sent Events (SSE) is a server push technology enabling a client to receive automatic updates from a server via HTTP connection, and describes how servers can initiate data transmission towards clients once an initial client connection has been established.
Server Sent Event is a good choice when we need to notify the browser.
-- wikipedia

If you're working with Amazon API Gateway and WebSocket in order to notify your clients this connection can be more expensive.

SSE can be a good choice when our application needs to send a message to it's clients.

This is a simple example how we can implementing SSE in Go.

//main.go
package main

import (
    "bytes"
    "encoding/json"
    "fmt"
    "math/rand"
    "net/http"
    "time"

    "github.com/gofiber/adaptor/v2"
    "github.com/gofiber/fiber/v2"
)

type Client struct {
    name   string
    events chan *DashBoard
}
type DashBoard struct {
    User uint
}

func main() {
    app := fiber.New()
    app.Get("/sse", adaptor.HTTPHandler(handler(dashboardHandler)))
    app.Listen(":3000")
}

func handler(f http.HandlerFunc) http.Handler {
    return http.HandlerFunc(f)
}
func dashboardHandler(w http.ResponseWriter, r *http.Request) {
    client := &Client{name: r.RemoteAddr, events: make(chan *DashBoard, 10)}
    go updateDashboard(client)

    w.Header().Set("Access-Control-Allow-Origin", "*")
    w.Header().Set("Access-Control-Allow-Headers", "Content-Type")
    w.Header().Set("Content-Type", "text/event-stream")
    w.Header().Set("Cache-Control", "no-cache")
    w.Header().Set("Connection", "keep-alive")

    timeout := time.After(1 * time.Second)
    select {
    case ev := <-client.events:
        var buf bytes.Buffer
        enc := json.NewEncoder(&buf)
        enc.Encode(ev)
        fmt.Fprintf(w, "data: %v\n\n", buf.String())
        fmt.Printf("data: %v\n", buf.String())
    case <-timeout:
        fmt.Fprintf(w, ": nothing to sent\n\n")
    }

    if f, ok := w.(http.Flusher); ok {
        f.Flush()
    }
}

func updateDashboard(client *Client) {
    for {
        db := &DashBoard{
            User: uint(rand.Uint32()),
        }
        client.events <- db
    }
}

// JS client
const source = new EventSource("http://localhost:3000/sse")
      source.onmessage = (event) => {
        console.log("OnMessage Called:")
        console.log(event)
        console.log(JSON.parse(event.data))
      }

Repository link

Por que Web Components?

Rafael Firmino — Mon, 02 Nov 2020 04:57:49 +0000

Fala dev, não sei como chegou aqui, mas este é o meu primeiro post na plataforma então vou me apresentar dessa vez.

Me chamo Rafael, sou apaixonado por desenvolvimento de software, atualmente trabalho como analista em uma plataforma a nível global. Me Viro no devops(Azure, aws, docker, jenkins), RabbitMq, lerna, elastic search, goFiber, docker-compose, Js, css, Vuejs, stencil...

Nos ultimos 2 anos eu tenho trabalhado bastante utilizando vuejs e sem sombra de dúvidas é uma ferramenta incrível!
No projeto atual nós temos a necessidade de utilizar grandes plugins pagos, como Aggrid, flexmonstrer, highcharts e outros grátis como vis-timeline, select2, sweetalert2.

Nem tudo são flores e no desenvolvimento de software o problema e no mundo de components também não. Um dos problemas começa quando o time, tendência ou falta de tempo nos forçam a utilizar wrappers. wrappers ou adapters são utilizados para criar uma camada de abstração entre o framework e a library que deseja utilizar.

O problema desse wrapper é que ele nem sempre acompanha as versões da biblioteca. Um exemplo claro de um é o vis-timeline que atualmente a lib está 10 versões a frente do wrapper. A mesma coisa ocorre com aggrid, Flexmonster e Hightcharts.

Não precisaríamos pensar em utilizar wrappers se as bibliotecas fossem realmente agnósticas a framework. Já precisou customizar alguma lib em um framework vue, react ou svelt. As vezes é mais complicado do que parece e "gambiarras" para adicionar comportamentos surgem nesse momento.

Recentemente estive pensando bastante como criar componentes realmente customizáveis e principalmente reutilizáveis independente de framework, foi onde me deparei com um carinha chamado Stencil.

Stencil é um conjunto de ferramentas para a construção de sistemas de design reutilizáveis e escaláveis. Gere componentes da Web pequenos, extremamente rápidos e 100% baseados em padrões que são executados em todos os navegadores.

Penso que Web Components é o caminho para criarmos bibliotecas de qualidade, agnósticas, testáveis, com os seus comportamentos isolados, CUSTOMIZÁVEIS e REUTILIZÁVEIS.

Estou criando um Web Component chamado componentt-toast Tem muita coisa ainda a ser feita mas já da pra pegar a ideia e ver o quão fácil é o Stencil. Sinta-se livre para contribuir.

Obrigado :)