DEV Community: Thiago Emidio

Um pouco de Java17

Thiago Emidio — Sun, 20 Oct 2024 20:01:25 +0000

Sealed Classes

Sealed Classes foram introduzidas no Java 17 como parte das melhorias relacionadas à programação orientada a objetos, permitindo uma maior restrição a herança de classes. Essa funcionalidade oferece mais controle sobre quais classes podem estender ou implementar uma classe ou interface, ajudando a manter o código mais seguro.

Vamos criar um tutorial passo a passo sobre como usar Sealed Classes em Java 17.

Primeiramente vamos criar uma classe chamada Banco e vamos adicionar a ela o modificador “sealed”, que controla como outras classes ou interfaces podem estender ou implementar a classe ou interface.

Fazendo isso, podemos ver que temos um erro indicando que a classe Banco com modificador “sealed” precisa ter subclasses.

Para resolver este problema, vamos criar uma classe chamada Cliente e adicionando a cláusula “permits” a classe Banco.

Fazendo isso podemos ver que termos o seguinte erro.

> Invalid permits clause: ‘Cliente’ must directly extend ‘Banco’

É isso mesmo que você está pensando, para resolver este problema precisamos extender a classe Banco diretamente na classe Cliente.

Isso resolve nosso problema e com isso ja conseguimos utilizar nossa Sealed Classe, legal não e mesmo ?

> OBS: O conceito de sealed também pode ser aplicado a interfaces em Java 17. Assim como em classes, uma interface selada pode restringir quais outras interfaces ou classes podem implementá-la.

Conclusão:
Sealed Classes oferecem uma forma poderosa de restringir e controlar herança em Java. Com isso, você pode evitar que classes sejam estendidas por engano, melhorando a legibilidade e a segurança do código.

Monitoramento e visualização de métricas com Docker Compose, Prometheus e Grafana.

Thiago Emidio — Fri, 31 May 2024 10:07:57 +0000

Introdução:

Prometheus e Grafana são duas ferramentas utilizadas no monitoramento e visualização de métricas de aplicações, porem têm propósitos e funcionalidades diferentes. Durante este tutorial, vamos ver quais a diferenças e como utilizadas.

Prometheus:
O Prometheus é uma ferramenta de monitoramento e sistema de alerta. Ele é projetado para coletar e armazenar métricas de sistemas e aplicações.

O Prometheus possui um sistema de alertas embutido, onde você pode definir regras de alerta que serão analisadas, e se uma condição for atendida, o Prometheus enviará alertas para várias integrações, como e-mail, Slack por exemplo.

Grafana:
O Grafana é uma plataforma de visualização de métricas. Ele é usado para criar dashboards interativos e gráficos a partir de várias fontes de dados como o Prometheus, InfluxDB, Graphite, Elasticsearch.

Para começar a monitorar uma aplicação Spring Boot com Prometheus e Grafana, vamos configurar um ambiente usando Docker Compose. Primeiro, precisamos criar um arquivo docker-compose.yml com os serviços do Prometheus e Grafana.

prometheus:
    image: prom/prometheus:latest
    container_name: prometheus
    volumes:
      - "./src/main/resources/prometheus.yml:/etc/prometheus/prometheus.yml"
    command:
      - "--config.file=/etc/prometheus/prometheus.yml"
    ports:
      - "9090:9090"

  grafana:
    image: grafana/grafana:9.5.15
    container_name: grafana
    restart: unless-stopped
    ports:
      - "3000:3000"
    environment:
      - GF_SECURITY_ADMIN_USER=admin
      - GF_SECURITY_ADMIN_PASSWORD=admin
      - GF_USERS_ALLOW_SIGN_UP=false
    volumes:
      - ./grafana/provisioning:/etc/grafana/provisioning
    depends_on:
      - prometheus
    healthcheck:
      test: [ "CMD", "nc", "-z", "localhost", "3000" ]

Vamos, precisar também configurar o arquivo prometheus.ym do Prometheus, ele e o responsável por coletar o onde configuramos os alvos de scraping, ou seja, os endpoints que o Prometheus irá coletar métricas.

Para o Grafana, precisamos configurar um painel para visualizar as métricas coletadas pelo Prometheus.

# my global config
global:
  scrape_interval:     15s # Set the scrape interval to every 15 seconds. Default is every 1 minute.
  evaluation_interval: 15s # Evaluate rules every 15 seconds. The default is every 1 minute.
  # scrape_timeout is set to the global default (10s).


# A scrape configuration containing exactly one endpoint to scrape:
# Here it's Prometheus itself.
scrape_configs:
  # The job name is added as a label `job=<job_name>` to any timeseries scraped from this config.
  - job_name: 'prometheus'

    # metrics_path defaults to '/metrics'
    # scheme defaults to 'http'.
    static_configs:
      - targets: ['127.0.0.1:9090']

    - job_name: 'spring-boot-actuator'
    scrape_interval: 5s # Define a frequência com que o Prometheus deve coletar métricas
    metrics_path: '/actuator/prometheus' # O caminho onde as métricas do Micrometer são expostas
    static_configs:
      - targets: ['host.docker.internal:8080'] # O endpoint da sua aplicação Spring Boot
        labels:
          application: book-api

  - job_name: 'grafana'
    metrics_path: '/'
    scrape_interval: 5s
    static_configs:
      - targets: ['127.0.0.1:3000']

OBS: Na minha tag targets, eu configurei o host da minha aplicação desta da seguinte forma host.docker.internal, isso por que minha aplicação esta rodando em um container docker.

Vamos configurar o application.yml da nossa aplicação.

management:
  endpoints:
    web:
      base-path: /actuator
      exposure:
        include: "*"
  endpoint:
    prometheus:
        enabled: true
    metrics:
        enabled: true

Vamos também adicionar duas dependências no nosso POM.xml.
A dependencia do actuator e a dependencia do prometheus.

A dependência spring-boot-starter-actuator é uma dependência que fornece recursos de monitoramento e gerenciamento.

A dependência micrometer-registry-prometheus é utilizada para integrar o Spring Boot Actuator com o Micrometer e o Prometheus.

<dependency>
   <groupId>org.springframework.boot</groupId>
   <artifactId>spring-boot-starter-actuator</artifactId>
</dependency>

<dependency>
   <groupId>io.micrometer</groupId>
   <artifactId>micrometer-registry-prometheus</artifactId>
</dependency>

Feito isso vamos executar o comando docker-compose up -d e veremos os containers iniciados.

Acessando a url do Prometheus http://localhost:9090, podemos ver que os serviços estão com o status “UP”, ou seja, estão saudáveis e funcionando.

Agora, vamos configurar os gráficos de monitoramento do Grafana. Acesse a url http://localhost:3000/connections/connect-data, e pesquise por Prometheus

Clique na opção “Create a Prometheus data source”, preencha o campo URL com a url do Prometheus, no caso como meu Prometheus esta em um container Docker precisamos pegar o IP do nosso container.

Execute o seguinte comando docker inspect

Na seção Networks > IPAddress: “192.168.240.3”, feito isso adicione do campo URL e clique em salvar.

Agora vamos configurar os gráficos de monitoramento do Grafana.

Acesse a url http://localhost:3000/dashboards

Acesse a opção New > Import e adicione a url http://grafana.com/grafana/dashboards/4701, essa URL e um gráfico disponibilizado no próprio site do Grafana, mas você pode escolher outros tipos de gráfico conforme a sua necessidade. Feito isso clique em load.

Depois disso, selecione Prometheus no campo de datasource e clique em Import.

Em seguida, podemos ver o gráfico com os dados do coletados pelo nosso Prometheus. Lindo não é mesmo ?

Conclusão:

O monitoramento de uma aplicação é uma maneira de garantir que sua aplicação esteja funcionando de forma confiável e eficiente. Ao coletar e visualizar métricas importantes, você pode identificar problemas de desempenho, capacidade e disponibilidade antes que eles afetem os usuários finais. Estas ferramentas oferecem uma solução poderosa e flexível para monitorar e manter a saúde de suas aplicações em produção.

Entendendo o Amazon DynamoDB

Thiago Emidio — Wed, 22 May 2024 18:15:18 +0000

Introdução:

O Amazon DynamoDB é um serviço de banco de dados NoSQL totalmente gerenciado, oferecido pela Amazon Web Services (AWS). Ele é projetado para lidar com grandes quantidades de tráfego de dados, proporcionando uma latência consistente.

Tabelas, Itens e Atributos:

Tabelas: O DynamoDB armazena dados em tabelas, que são coleções de itens.
Itens: Cada tabela contém zero ou mais itens. Um item é uma coleção de atributos.
Atributos: Cada atributo tem um nome e um valor. O valor pode ser um escalar (string, número, binário), um conjunto (conjunto de strings, números ou binários), ou um mapa (estrutura de dados aninhada).

Chaves Primárias:
Chave de Partição (Hash Key):
Uma chave de partição é usada para distribuir itens entre partições de armazenamento e e obrigatória para todas as tabelas.

Chave de Partição e Chave de Classificação (Range Key):
Além da chave de partição, uma chave de classificação é usada para ordenar os itens com a mesma chave de partição. É opcional.

Particionamento e Escalabilidade
DynamoDB distribui automaticamente dados entre várias partições físicas para gerenciar a carga de leitura e escrita, e também armazenar grandes volumes de dados. Cada partição é responsável por um subconjunto dos dados da tabela.

A chave de partição (hash key) é usada para determinar em qual partição física um item específico será armazenado. Isso garante uma distribuição uniforme dos dados.

Conforme os dados da sua tabela aumentam, o DynamoDB automaticamente adiciona mais partições.

Replicação e Disponibilidade:
As Global Tables permitem replicar dados entre várias regiões da AWS. Ao criar uma tabela global, o DynamoDB cria réplicas da tabela original em cada região especificada.

DynamoDB Streams captura todas as alterações de dados na tabela (inserções, atualizações, exclusões). Os eventos nas streams são ordenados, garantindo que as mudanças sejam aplicadas na mesma ordem em todas as réplicas, o que ajuda a manter a consistência dos dados.

Quando um item é atualizado em uma região, o DynamoDB propaga essa alteração para todas as outras réplicas de maneira assíncrona.

Se houver conflitos de escrita (por exemplo, quando o mesmo item é atualizado simultaneamente em diferentes regiões), o DynamoDB resolve esses conflitos usando uma abordagem de “Last Writer Wins”, onde a atualização mais recente (com base no timestamp) prevalece.

Conclusão
O DynamoDB fornece um mecanismo robusto para replicação e consistência de dados em múltiplas regiões AWS. Através do uso de streams e políticas de resolução de conflitos, ele mantém os dados sincronizados e atualizados, prevenindo a maioria dos problemas de dados desatualizados.

fontes:

Introdução às Coroutines em Kotlin: Simplificando Operações Assíncronas

Thiago Emidio — Wed, 31 Jan 2024 19:28:02 +0000

Introdução:

Coroutines em Kotlin oferecem uma maneira eficiente de lidar com operações assíncronas, tornando o código mais legível e fácil de manter. Elas são uma alternativa leve às tradicionais callbacks ou às primitivas de concorrência, permitindo que você escreva código assíncrono de maneira sequencial. Neste tutorial, exploraremos uma introdução básica às coroutines em Kotlin, apresentaremos um exemplo prático e concluiremos com insights sobre seu uso e benefícios.

Exemplo:

Vamos criar um exemplo prático usando coroutines para gerar números de pedido de maneira assíncrona. Primeiro, definiremos uma função generate que simula uma operação assíncrona para obter um número de pedido:

import kotlinx.coroutines.*

suspend fun generate(): String {
    val currentLocale: java.util.Locale = java.util.Locale.getDefault()
    val countryCode: String = currentLocale.country
    val order = generateSequence(1) { it + 1 }
        .take(1)
        .distinct()
        .sorted()
        .toSet()

    val number = order.stream().findFirst().get()
    val orderNumber = countryCode + number
    println("Order number: $orderNumber")
    return orderNumber
}

Agora, usaremos runBlocking para criar um escopo de coroutine bloqueante e chamar a função generate de maneira síncrona:

import kotlinx.coroutines.runBlocking

fun main() {
    runBlocking {
        println("Start of execution ")
        val orderNumber: String = generate()
        println("Coroutine completed with order number: $orderNumber")
    }

    println("Main program continues while the coroutine is running.")
}

Conclusão:

Como podemos ver, as coroutines em Kotlin oferecem uma abordagem simples e poderosa para lidar com operações assíncronas. Elas simplificam o código, tornando-o mais compreensível e evitando o callback hell associado a abordagens tradicionais. A utilização de runBlocking para simplificar o uso de coroutines em funções main ou em scripts pode ser adequada em certos contextos, mas em aplicações mais complexas, é recomendável o uso de escopos de coroutine mais específicos. Ao integrar coroutines em seus projetos Kotlin, você pode aproveitar os benefícios da concorrência sem sacrificar a legibilidade do código.

Fontes:

Criando um bucket S3 na AWS usando Terraform.

Thiago Emidio — Thu, 13 Jul 2023 17:55:57 +0000

Neste tutorial, você aprenderá como criar um bucket S3 na AWS usando o Terraform. O Terraform é uma ferramenta de infraestrutura como código (IaC) que permite definir e provisionar recursos de infraestrutura de forma automatizada.

Pré-requisitos
Antes de começar, certifique-se de ter o seguinte:

Uma conta na AWS com as credenciais de acesso configuradas.
O Terraform instalado na sua máquina. Você pode baixá-lo em no site oficial do Terraform.

Passo 1: Configurando o projeto
Crie um diretório para o seu projeto e acesse-o no terminal.

Dentro do diretório do projeto, crie três arquivos: main.tf, variables.tf e providers.tf.

O arquivo main.tf conterá a configuração do bucket S3 e os recursos relacionados.
O arquivo variables.tf conterá as variáveis que você deseja configurar para o seu bucket.
O arquivo providers.tf conterá as configurações do provedor da AWS.

Passo 2: Configurando o arquivo main.tf
Abra o arquivo main.tf e adicione o seguinte código:

resource "aws_s3_bucket" "my_bucket" {
  bucket = var.bucket_name

  tags = {
    Name        = "my-bucket-test-tutorial"
    Environment = var.environment
  }
}

O recurso aws_s3_bucket define um bucket na AWS. O nome do bucket é definido usando a variável var.bucket_name.
As tags são usadas para adicionar metadados ao bucket, como nome e ambiente. As tags são definidas no bloco tags usando pares chave-valor.

Passo 3: Configurando o arquivo variables.tf
Abra o arquivo variables.tf e adicione o seguinte código:

variable "bucket_name" {
  type        = string
  description = "Nome do bucket da AWS"
}

variable "environment" {
  type        = string
  description = "Ambiente do bucket da AWS"
}

As variáveis bucket_name e environment são definidas para permitir a personalização do nome do bucket e do ambiente. O tipo das variáveis é definido como string e uma descrição é fornecida para facilitar o entendimento.

Passo 4: Configurando o arquivo providers.tf
Abra o arquivo providers.tf e adicione o seguinte código:

provider "aws" {
  region = "us-east-1"
  access_key = var.aws_access_key
  secret_access_key = var.aws_secret_access_key
}

O provedor aws é configurado com a região da AWS que você deseja usar. No exemplo acima, a região é definida como us-east-1. Certifique-se de substituir esse valor pela região desejada.
As chaves de acesso da AWS são definidas usando as variáveis var.aws_access_key e var.aws_secret_access_key. Certifique-se de fornecer esses valores corretamente. Você pode definir essas variáveis em um arquivo terraform.tfvars ou passá-las por linha de comando.

Passo 5: Executando o Terraform
Abra o terminal e navegue até o diretório do projeto.

Execute o comando terraform init para inicializar o diretório do projeto e baixar os provedores necessários.
Execute o comando terraform plan para visualizar as alterações planejadas pelo Terraform.

Execute o comando terraform apply para criar o bucket na AWS com base nas configurações fornecidas. No final, voce sera perguntando se gostaria de continuar com esta ação, apenas digite “Yes”.

Após alguns instantes, o Terraform criará o bucket na AWS. Você verá uma mensagem indicando o sucesso da operação.

Agora você já pode acessar sua conta da AWS e ver seu bucket criado.

Conclusão
Parabéns! Você criou um bucket na AWS usando o Terraform. Agora você pode usar esse bucket para armazenar objetos e aproveitar outros recursos do S3.

Enjoy :)

Enviando mensagens de texto com o Twilio utilizando Java e Spring Boot: Um guia passo a passo.

Thiago Emidio — Thu, 15 Jun 2023 17:01:36 +0000

O que é o Twilio:

O Twilio é uma plataforma de comunicação em nuvem que permite a integração de serviços de mensagens, voz e vídeo em aplicativos. Neste artigo, exploraremos como enviar mensagens de texto usando o Twilio em conjunto com o framework Spring Boot em Java. Você aprenderá como adicionar a biblioteca do Twilio no seu projeto Spring Boot e enviar mensagens de texto programaticamente.

Caso nao tenha um conta, acesse o site do Twilio para criar sua conta.

O Twilio ira liberar um número de telefone e credenciais para a utilização do serviços.

Adicionando dependencia do Twilio.

A primeira coisa que devemos fazer e configurar a biblioteca do Twilio no projeto. Adicione a dependência do Twilio SDK ao seu projeto Spring Boot. Isso pode ser feito através do Maven ou do Gradle, dependendo do seu gerenciador de dependências preferido. A dependência fornecerá as classes e métodos necessários para interagir com a API do Twilio. Lembre-se de importar as classes relevantes no seu código

<dependency>
    <groupId>com.twilio.sdk</groupId>
    <artifactId>twilio</artifactId>
    <version>8.17.0</version>
</dependency>

Configuração das credenciais do Twilio

No arquivo application.properties ou application.yml do Spring Boot, adicione as seguintes propriedades:

twilio.accountSid=YOUR_ACCOUNT_SID
twilio.authToken=YOUR_AUTH_TOKEN
twilio.phoneNumber=YOUR_PHONE_NUMBER

Substitua YOUR_ACCOUNT_SID, YOUR_AUTH_TOKEN e YOUR_PHONE_NUMBER pelas suas credenciais e número de telefone que o Twilio forneceu.

Abaixo temos o objeto que vamos usar na nossa Request.

public class SMSRequest {
    private String to;       // Número de telefone de destino
    private String message;  // Mensagem de texto a ser enviada

    // Getters e setters

}

Crie um controlador Spring para enviar mensagens de texto.

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class SMSController {

    private final TwilioService twilioService;

    @Autowired
    public SMSController(TwilioService twilioService) {
        this.twilioService = twilioService;
    }

    @PostMapping("/send-sms")
    public void sendSMS(@RequestBody SMSRequest request) {
        twilioService.sendSMS(request.getTo(), request.getMessage());
    }
}

Na camada de serviço é onde tudo ira acontecer, iremos realizar a chamada para o serviço do Twilio passando nossas credenciais que criamos no site do Twilio

Repare que no objeto SMSRequest temos a variável “To” que sera usada para armazenar o numero de telefone que queremos enviar a mensagem de texto.

import com.twilio.Twilio;
import com.twilio.rest.api.v2010.account.Message;
import com.twilio.type.PhoneNumber;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Service;

@Service
public class TwilioService {

    @Value("${twilio.accountSid}")
    private String accountSid;

    @Value("${twilio.authToken}")
    private String authToken;

    @Value("${twilio.phoneNumber}")
    private String phoneNumber;

    public void sendSMS(String to, String message) {
        Twilio.init(accountSid, authToken);

        Message.creator(
                new PhoneNumber(to),
                new PhoneNumber(phoneNumber),
                message
        ).create();
    }
}

Testando o envio de mensagens.

Inicie o servidor Spring Boot e envie uma solicitação POST para a rota /send-sms, passando o número de telefone de destino e a mensagem no corpo da solicitação. Conforme o exemplo abaixo:

{
    "to": "+15555555555",
    "message": "Olá! Esta é uma mensagem de teste do Twilio."
}

Conclusão:

Neste artigo, exploramos como enviar mensagens de texto com o Twilio usando Java e o framework Spring Boot. Adicionamos a biblioteca Twilio ao projeto e enviamos mensagens de texto programaticamente. O Twilio oferece uma API robusta e fácil de usar, permitindo comunicação eficiente por meio de mensagens de texto. Espero que tenha ajudado!

Java 17 - Records

Thiago Emidio — Wed, 14 Jun 2023 21:30:58 +0000

Hoje vamos falar da feature Record. :)

A funcionalidade de record no Java 17 é uma nova adição à linguagem que simplifica a criação de classes de dados imutáveis. Ela combina várias características, como geração automática de campos, geração de construtores e implementações padrão de métodos comuns como equals(), hashCode() e toString(). Records são declarados usando a palavra-chave "record", seguida pelo nome e uma lista de componentes.

Abaixo está um exemplo de declaração simples de um record:



record Pessoa(String nome, int idade) {
 // Corpo do record (opcional)
}

No exemplo acima, declaramos um record chamado "Pessoa" com dois componentes: um campo de string "nome" e um campo de inteiro "idade". O record gera automaticamente um construtor, getters para cada componente e implementações padrão de equals(), hashCode() e toString().
Você pode criar uma instância de um record usando o construtor como qualquer outra classe:



Pessoa pessoa = new Pessoa("Thiago", 35);

Records são imutáveis por padrão, o que significa que seus campos não podem ser modificados depois de inicializados. No entanto, você ainda pode atualizar uma instância de record criando um novo record com valores atualizados usando a palavra-chave "with":



Pessoa pessoaAtualizada = pessoa.withIdade(31);

Nesse exemplo, uma nova instância de record chamada "pessoaAtualizada" é criada com o mesmo nome do record original, mas com a idade atualizada para 31. O método "withIdade()" é gerado automaticamente pelo record.
Records também podem ser usados em declarações de switch:



public String obterDescricaoPessoa(Pessoa pessoa) {
 return switch (pessoa.idade()) {
 case 0 -> "Recém-nascido";
 case 18 -> "Adulto";
 default -> "Desconhecido";
 };
}

Nesse exemplo, o método "obterDescricaoPessoa" recebe um record de pessoa como parâmetro e usa uma declaração de switch para retornar uma descrição com base na idade.

*Conclusão: *
No geral, a funcionalidade de record no Java 17 oferece uma forma conveniente de criar classes de dados imutáveis e com um código de fácil manutenção. Ela melhora a legibilidade do código e reduz o esforço necessário para criar e usar tais classes.