Ambiente Docker online e gratuito para testes de containers

O Docker revolucionou a forma como criamos, distribuímos e executamos aplicações. Mas nem sempre temos um ambiente configurado para experimentar ou aprender sobre essa tecnologia poderosa. É aqui que o Play With Docker brilha. Essa plataforma gratuita oferece um ambiente pronto para explorar o Docker, diretamente no navegador.

O Play With Docker é uma plataforma interativa que permite:

• Criar instâncias temporárias para executar containers.
• Praticar comandos do Docker em um terminal baseado em Linux.
• Testar configurações de rede entre containers.
• Experimentar tutoriais e conceitos avançados, como Docker Compose, Swarm e volumes.
• Tudo isso sem precisar instalar nada no seu computador!

Como começar

Ter uma conta no Docker Hub para logar na plataforma Play With Docker

Caso ainda não tiver uma conta no Docker Hub, crie uma gratuitamente

Após logar na plataforma Play With Docker, crie sessões, inicie uma nova sessão e comece a explorar. Você terá até 4 horas por sessão.

Pode adicionar nós, teste múltiplos containers ou crie clusters usando até 5 nós.

Principais funcionalidades

• Ambiente seguro e temporário:

Ideal para testes rápidos.

• Interface simples:

Terminal Linux no navegador. Também pode conectar no SSH da plataforma, basta copiar o endereço no campo SSH e colar no seu terminal e pronto para executar containers usando o terminal do seu computador conectado na plataforma.

Casos de Uso

• Aprendizado inicial:

Execute comandos básicos do Docker sem se preocupar com instalação.

• Testes de configuração:

Simule redes, volumes e clusters.

• Demonstrações rápidas:

Ideal para workshops e apresentações.

Limitações

Sessões são temporárias (máximo de 4 horas).

Recursos limitados em comparação com um ambiente local ou servidor dedicado.

Considerações finais

O Play With Docker é uma excelente ferramenta para quem quer aprender Docker de maneira prática e acessível. Seja para explorar novos conceitos, realizar testes rápidos ou ensinar colegas, ele elimina barreiras iniciais e torna o aprendizado muito mais fluido.

Referências

https://labs.play-with-docker.com/

Feito!

Utilizando o Faker para criar mocks de API REST

O Faker é uma aplicação de código aberto desenvolvida em Java que ajuda a separar o desenvolvimento frontend do backend, eliminando a necessidade de esperar pelo desenvolvimento da API. Este guia apresenta os passos para criar mocks de API REST usando o Faker e Docker.

Procedimentos:

1. Instalação do Docker:

Certifique-se de ter o Docker instalado em seu sistema para facilitar o uso do Faker.

Caso ainda não tenha o Docker instalado na distro Linux com base Debian, então execute no terminal:

$ sudo apt install docker.io docker-compose

2. Configuração do diretório mocks:

Crie um diretório chamado "mocks" em seu sistema. Dentro deste diretório, crie arquivos JSON para definir os mocks de API.

3. Exemplo de arquivo JSON:

Um exemplo de arquivo JSON para um mock de usuários pode ser assim:

{
  "plugins": [
    {
      "name": "list",
      "args": {
        "count": 5,
        "item": {
          "id": "#random:int:min=1&max=1000#",
          "name": "#random:name#",
          "created_at": "#timestamp#",
          "updated_at": "#timestamp#"
        }
      }
    },
    {"name": "random"},
    {"name": "timestamp"}
  ],
  "request": {
    "method": "GET",
    "path": "/v1/users"
  },
  "response": {
    "body": []
  }
}

Este exemplo define um mock para a rota "/v1/users" que retorna uma lista de 5 usuários com campos como "id", "name", "created_at" e "updated_at" gerados aleatoriamente.

4. Execução do container Docker:

Utilize o seguinte comando Docker para executar o Faker:

docker run --rm -p 3030:3030 -v /diretorio/mocks:/app/mocks dotronglong/faker:stable

Este exemplo define um mock para a rota "/v1/users" que retorna uma lista de 5 usuários com campos como "id", "name", "created_at" e "updated_at" gerados aleatoriamente.

Certifique-se de substituir "/diretorio/mocks" pelo caminho absoluto para o diretório de mocks que você criou anteriormente.

5. Acessando os mocks de API:

Após iniciar o container Docker, você pode acessar os mocks de API através do seguinte endpoint:

curl http://localhost:3030/v1/users

OU no browser http://localhost:3030/v1/users

6. Recursos adicionais:

Para mais informações e recursos sobre o Faker, consulte o repositório oficial no GitHub:

https://github.com/dotronglong/faker

7. Adicionar o Faker Mock no arquivo docker-compose.yml

No diretório, onde estão os arquivos JSON com dados de mock, crie o arquivo

docker-compose.yml, conforme abaixo:

version: '3.8'

services:
  mock_faker:
    image: dotronglong/faker:stable
    container_name: mock_faker
    ports:
      - "3030:3030"
    volumes:
      - ".:/app/mocks"
    restart: unless-stopped

Caso, tenha Faker Mock já está em execução, é necessário finalizar, com docker kill

Depois, execute docker-compose up -d

Adicione a URL do Faker Mock com o endpoint definido no arquivo JSON no Postman com o verbo HTTP (GET ou POST).

Feito!

Sua API é REST? Descubra agora

No mundo do desenvolvimento de software, o termo "API REST" tornou-se um padrão amplamente utilizado para integração entre sistemas. No entanto, nem todas as APIs que se apresentam como RESTful seguem, de fato, os princípios fundamentais do REST. Aderir a esses princípios não é apenas uma questão de semântica, mas também de garantir consistência, escalabilidade e facilidade de uso para os desenvolvedores que consomem sua API.

Neste artigo, exploraremos os elementos essenciais que definem uma API RESTful e apresentaremos um guia prático para ajudar você a verificar se sua API está verdadeiramente alinhada a esse padrão.

Descubra como estruturar endpoints, utilizar métodos HTTP corretamente e aplicar boas práticas que tornam sua API mais eficiente e aderente aos conceitos do REST.

O REST (Representational State Transfer) é um estilo arquitetural que define um conjunto de restrições para a criação de serviços web escaláveis e eficientes. Ele foi introduzido por Roy Fielding em sua tese de doutorado em 2000 e tem se tornado a base para a construção de APIs modernas. Para que uma API seja considerada RESTful, ela deve seguir seis princípios fundamentais:

1. Cliente-Servidor

A arquitetura REST é baseada na separação entre cliente e servidor, o que permite que ambos evoluam de forma independente. O cliente é responsável pela interface do usuário e pela experiência do usuário, enquanto o servidor gerencia o armazenamento e a lógica dos dados. Essa separação melhora a portabilidade do cliente e a escalabilidade do servidor.

2. Stateless (sem estado)

Cada requisição do cliente ao servidor deve conter todas as informações necessárias para que o servidor entenda e processe o pedido. O servidor não deve armazenar informações sobre o estado do cliente entre as requisições. Isso significa que cada chamada é independente, permitindo que as requisições sejam feitas em qualquer ordem.

3. Cacheável

As respostas das APIs REST devem ser rotuladas como cacheáveis ou não, permitindo que os clientes armazenem em cache as respostas para otimizar o desempenho. Isso reduz a necessidade de chamadas repetidas ao servidor para obter os mesmos dados, melhorando a eficiência da comunicação.

4. Interface uniforme

Uma interface uniforme simplifica e desacopla a arquitetura, permitindo que diferentes clientes interajam com o servidor de maneira padronizada. Isso geralmente é implementado através dos métodos HTTP padrão (GET, POST, PUT, DELETE), que definem claramente as operações permitidas em recursos específicos.

5. Sistema em camadas

A arquitetura REST pode ser composta por várias camadas hierárquicas, onde cada camada não conhece as camadas além daquela com a qual está interagindo. Isso permite que intermediários, como proxies e gateways, sejam utilizados para melhorar a segurança e a escalabilidade sem que o cliente precise conhecer a complexidade interna do servidor.

6. Código sob demanda (opcional)

Embora não seja uma exigência, as APIs REST podem permitir que o servidor envie código executável ao cliente quando necessário, estendendo a funcionalidade do cliente sem exigir atualizações constantes.

Diferença entre API REST e RESTful

REST: Conjunto de princípios arquiteturais.

RESTful: Implementação desses princípios em um sistema específico.

Exemplos de endpoints da API de Produtos

• Forma errada de endpoints

A forma incorreta de definir os endpoints para uma API de produtos pode levar a confusões e não seguir as melhores práticas do REST. Aqui estão alguns exemplos de endpoints mal estruturados:

/cadastrarProduto

/editarProduto

/atualizarProduto

/excluirProduto

Esses endpoints não representam recursos, mas sim ações específicas. Isso vai contra o princípio do REST, que enfatiza a manipulação de recursos através de URLs que representam entidades.

• Forma correta de endpoints

A seguir, apresentamos uma forma correta e mais alinhada com os princípios REST para a API de produtos:

1. Criar um Produto

POST /produtos

Sucesso: 201 Created

Erro: 422 Unprocessable Entity

O /produtos representa a coleção de produtos. O método POST é utilizado para criar um novo produto. Caso ocorre algum erro, deve retornar uma mensagem em JSON com código de status 422.

2. Listar todos os produtos

GET /produtos

Permite recuperar uma lista de todos os produtos. Caso, não tiver nenhum produto, deve retornar uma lista vazia.

3. Recuperar um produto específico

GET /produtos/1

Sucesso: 200 OK

Erro: 404 Not Found

Isso é para visualizar um produto específico pela sua identificação (ID). O número 1 representa o ID do produto ou caso o produto não existir deve retornar uma mensagem em JSON com código de status 404.

4. Atualizar um produto existente

PUT /produtos/1

Sucesso: 200 OK

Erro: 404 Not Found

O método PUT é utilizado para atualizar os dados de um produto existente, identificado pelo ID 1 ou caso o produto não existir deve retornar uma mensagem em JSON com código de status 404.

5. Excluir um Produto

DELETE /produtos/1

Sucesso: 200 OK

Erro: 404 Not Found

O método DELETE remove o produto identificado pelo ID 1 ou caso o produto não existir deve retornar uma mensagem em JSON com código de status 404.

Considerações finais

Ao projetar uma API, é fundamental seguir os princípios REST para garantir que os endpoints sejam intuitivos e representem recursos em vez de ações. Isso não apenas melhora a clareza e a usabilidade da API, mas também facilita a manutenção e a escalabilidade no futuro.

Os princípios fundamentais do REST garantem uma comunicação eficiente entre sistemas, promovendo flexibilidade, escalabilidade e interoperabilidade. A adoção dessas diretrizes no desenvolvimento de APIs tem contribuído para o crescimento das aplicações web modernas, especialmente aquelas baseadas em nuvem.

Referência

FIELDING, Roy Thomas. Architectural styles and the design of network-based software architectures. 2000. Dissertação (Doutorado em Ciência da Computação) - University of California, Irvine, 2000. Disponível em: Architectural styles and the design of network-based software architectures . Acesso em: 06/12/2024.

Feito!

Entendendo a JVM

O que é a JVM e por que ela é tão importante?

A Java Virtual Machine (JVM) é um dos pilares mais importantes da linguagem Java. Ela permite que o Java alcance seu objetivo principal de ser portável, com o famoso lema "Write Once, Run Anywhere" (Escreva uma vez, execute em qualquer lugar).

Mas o que exatamente é a JVM? Em resumo, é uma máquina virtual que interpreta e executa o bytecode Java (arquivos .class), traduzindo-o para instruções compreensíveis pelo sistema operacional e hardware subjacente.

Graças à JVM, aplicações Java podem ser executadas em diferentes plataformas sem que o código precise ser reescrito, garantindo portabilidade, segurança e eficiência.

Arquitetura da JVM: Explorando os Componentes Internos

A JVM é composta por várias partes que trabalham juntas para executar programas Java.

1. Class Loader (Carregador de Classes)

O Class Loader é responsável por carregar os arquivos .class na memória no momento da execução. Ele organiza e gerencia as classes em diferentes níveis:

• Bootstrap Class Loader:

Carrega as classes fundamentais do Java.

• Extension Class Loader:

Lida com bibliotecas adicionais.

• Application Class Loader:

Carrega as classes da aplicação.

2. Área de Memória da JVM

A memória da JVM é organizada em várias áreas, cada uma com uma função específica:

• Heap:

Onde os objetos e instâncias são armazenados.

• Stack:

Armazena frames de métodos em execução e variáveis locais.

• Method Area:

Contém metadados das classes e bytecode.

• PC Register:

Rastrea a posição atual da instrução sendo executada em cada thread.

• Native Method Stack:

Suporte para métodos escritos em linguagens nativas, como C ou C++.

3. Execution Engine (Motor de Execução)

Essa é a parte da JVM que transforma o bytecode em instruções executáveis.

• Interpretador:

Executa o bytecode linha a linha.

• JIT Compiler (Just-In-Time):

Compila o bytecode em código nativo para acelerar a execução.

4. Native Interface

Permite que o Java interaja com bibliotecas nativas do sistema, facilitando a execução de código fora da JVM.

5. Garbage Collector (Coletor de Lixo)

Um recurso essencial da JVM que gerencia automaticamente a memória, removendo objetos não utilizados e evitando problemas como vazamentos de memória (memory leaks).

Como a JVM executa o código?

O processo de execução de um programa Java na JVM segue estas etapas:

• O compilador Java (javac) converte o código-fonte (.java) em bytecode (.class).
• O Class Loader carrega o bytecode na memória da JVM.
• O Motor de Execução interpreta ou compila o bytecode para código nativo.
• O código nativo é executado pelo hardware subjacente.

Diferenciando JVM, JRE e JDK

Ao trabalhar com Java, você encontrará três termos comuns:

JVM (Java Virtual Machine): É o ambiente de execução para programas Java.

JRE (Java Runtime Environment): Inclui a JVM e bibliotecas padrão necessárias para rodar aplicações.

JDK (Java Development Kit): Inclui o JRE, ferramentas de desenvolvimento (compilador, depurador, etc.) e bibliotecas adicionais.

Benefícios da JVM

• Portabilidade:

O bytecode é independente de plataforma, e a JVM específica de cada sistema operacional cuida da execução.

• Eficiência:

O JIT Compiler otimiza o desempenho em tempo de execução.

• Segurança:

Oferece isolamento entre o código Java e o hardware real, protegendo contra execuções maliciosas.

• Multithreading:

Suporte nativo para execução simultânea de threads.

• Gerenciamento de Memória:

O Garbage Collector simplifica o desenvolvimento e reduz problemas como vazamentos de memória.

Considerações finais

A Java Virtual Machine é a espinha dorsal do Java. Sua arquitetura robusta e características inovadoras garantem que aplicações sejam executadas de forma confiável, segura e eficiente em diferentes plataformas.

Entender como a JVM funciona não é apenas importante para desenvolvedores Java, mas também para quem deseja otimizar aplicações, resolver problemas de desempenho ou explorar áreas como DevOps e segurança.

Feito!

Comparativo entre MySQL e MariaDB: Aprenda como usá-los em containers Docker com DBeaver

MySQL e MariaDB são dois dos bancos de dados relacionais mais populares no mercado, amplamente usados em sistemas de produção. Ambos são Sistemas de Gerenciamento de Banco de Dados (SGBDs) que suportam operações complexas e escaláveis, atendendo a várias necessidades de armazenamento e manipulação de dados. Porém, eles têm diferenças notáveis, desde seu licenciamento até características de desempenho e inovação.

Neste artigo, vamos explorar as diferenças entre MySQL e MariaDB, explicar suas origens e uso, e demonstrar como configurar ambos em containers Docker para facilitar o desenvolvimento e o gerenciamento de banco de dados. Também abordaremos como conectá-los ao DBeaver para visualização e administração.

O que é um banco de dados e um SGBD?

Um banco de dados é uma coleção organizada de dados que permite o armazenamento e a recuperação rápida de informações. Para gerenciar, organizar e manipular esses dados de forma eficiente, usamos um Sistema de Gerenciamento de Banco de Dados (SGBD), que é um software que interage com os dados e com o usuário, facilitando operações como consultas, atualizações e análises.

Existem dois tipos principais de banco de dados:

Relacionais: Organizam os dados em tabelas com colunas e linhas, como o MySQL, MariaDB, PostgreSQL, Oracle, MS SQL Server. São ideais para dados estruturados e complexos.

NoSQL: São não-relacionais e oferecem maior flexibilidade para trabalhar com dados sem estrutura rígida, como JSON ou dados hierárquicos. Exemplos incluem MongoDB, Cassandra.

MySQL vs MariaDB:

MySQL foi desenvolvido inicialmente pela empresa sueca MySQL AB e se tornou rapidamente popular por sua velocidade e simplicidade. Em 2008, foi adquirido pela Oracle, o que gerou preocupação na comunidade de código aberto sobre o futuro do projeto. Em resposta, Michael Widenius, um dos fundadores do MySQL, criou um fork chamado MariaDB, que manteve o foco em ser completamente livre e aberto, além de adicionar inovações.

Principais Diferenças entre MySQL e MariaDB

Característica	MySQL	MariaDB
Licenciamento	GPL para Community Edition e versão comercial pela Oracle	GPL, totalmente de código aberto
Mecanismo de Armazenamento	InnoDB	Aria (padrão) e InnoDB opcional
Replicação e Clustering	Replicação Master-Slave, Master-Master	Suporta Galera Cluster para replicação síncrona
Suporte JSON	Suporte nativo	Suporte nativo e melhorias de desempenho
Otimizações de Desempenho	Foco em InnoDB e otimizações internas	Aria, cache de subconsultas e consultas paralelas otimizadas
Recuperação de Crashes	InnoDB com recuperação automática	Aria com recuperação rápida e segura
Novos Recursos	Suporte a JSON e novos tipos de dados	Compatibilidade com PL/SQL e ColumnStore
Atualizações e Inovações	Focada em estabilidade com novas funcionalidades controladas	Atualizações frequentes com inovações rápidas

Instalando e executando o MySQL E MariaDB no Docker

Execute no terminal Linux (Debian e derivados), se caso ainda não tiver o Docker instalado.

$ sudo apt update

$ sudo apt install docker.io docker-compose

Caso você ainda usa Windows, então segue os procedimentos para poder conseguir reproduzir os procedimentos desse artigo no seu computador Janeleiro!

Habilitar o WSL2:

Abra o PowerShell como administrador e execute:

wsl --install

O comando acima instala automaticamente o WSL e a versão Ubuntu padrão. Caso queira instalar uma distribuição específica, como o Ubuntu LTS, ela pode ser encontrada na Microsoft Store.

Configurar o WSL2:

Verifique a versão do WSL para garantir que é o WSL2. Para isso, execute:

wsl --set-default-version 2

Isso configura o WSL para rodar como WSL2 por padrão, o que melhora a performance e compatibilidade com o Docker.

Instalar o Docker Desktop

Baixe e instale o Docker Desktop para Windows. Durante a instalação, marque a opção para Usar WSL2 em vez de Hyper-V.

Depois de instalado, o Docker Desktop detectará automaticamente o WSL2, permitindo executar containers diretamente no ambiente Ubuntu do WSL.

Com o Docker configurado, você poderá seguir os mesmos comandos descritos no artigo para executar containers de MySQL e MariaDB usando o terminal do Ubuntu no WSL2.

Para desenvolvedores que buscam um ambiente mais próximo dos servidores de produção e com maior controle do sistema, migrar para uma distribuição Linux pode ser uma excelente opção. Muitos profissionais encontram no Linux uma plataforma robusta e personalizável para desenvolvimento!

Configurando MySQL e MariaDB com Docker

O uso de Docker para configurar e executar MySQL e MariaDB em containers é uma prática cada vez mais comum. Docker simplifica o processo de instalação e oferece portabilidade, ideal para ambientes de desenvolvimento e testes.

Executando MySQL com Docker

Para criar um container Docker para MySQL, execute:

docker run --name mysql-docker -e MYSQL_ROOT_PASSWORD=secret -e MYSQL_DATABASE=banco1 -p 3306:3306 -v mysql_data:/var/lib/mysql -d mysql:latest

Executando MariaDB com Docker

Para iniciar MariaDB em um container, use:

docker run --name mariadb-container -e MARIADB_ROOT_PASSWORD=secret -e MARIADB_DATABASE=banco2 -p 3307:3306 -v mariadb_data:/var/lib/mysql -d mariadb:latest

Conectando ao MySQL e MariaDB com DBeaver

DBeaver é uma ferramenta gráfica popular para gerenciar SGBDs, incluindo MySQL e MariaDB.

Execute no terminal Linux (Debian e derivados), se ainda não tiver instalado o DBeaver.

$ sudo apt install dbeaver-ce

Configurando conexão com MySQL no DBeaver

No DBeaver, vá em Database > New Database Connection.

Escolha MySQL na lista e configure:

Host: 127.0.0.1

Porta: 3306

Database: banco1

Username: root

Password: secret

Clique em Test Connection para verificar se a conexão com o container MySQL está funcionando.

Configurando conexão com MariaDB no DBeaver

No DBeaver, vá em Database > New Database Connection.

Escolha MariaDB e configure:

Host: 127.0.0.1

Porta: 3307

Database: banco2

Username: root

Password: secret

Após a configuração, você poderá gerenciar ambos os bancos de dados diretamente pelo DBeaver.

Clique em Test Connection para verificar a conexão com o container MariaDB.

Considerações finais

Tanto MySQL quanto MariaDB oferecem recursos poderosos e são amplamente utilizados em aplicações de produção. MariaDB é a escolha mais flexível e totalmente aberta, enquanto MySQL continua popular devido ao suporte e estabilidade oferecidos pela Oracle. A escolha entre MySQL e MariaDB depende das necessidades específicas do seu projeto, especialmente em relação ao licenciamento e aos recursos avançados. A configuração de ambos via Docker é simples e oferece um ambiente isolado para testes, desenvolvimento e operação.

Feito!

Instalando driver da NVIDIA no Ubuntu

O presente post, irá orientá-lo na instalação do driver NVIDIA no Ubuntu 24.04 e 24.10, permitindo que você aproveite ao máximo o desempenho da sua GPU NVIDIA. O processo inclui a verificação do driver recomendado para o seu sistema, instalação do driver, configuração do Secure Boot (se aplicável) e uma verificação final para garantir que o driver esteja ativo.

Atualizar o sistema

No terminal, execute os comandos abaixo para garantir que o sistema esteja atualizado:

$ sudo apt update

$ sudo apt upgrade

Verificar o driver NVIDIA compatível

Para ver qual versão do driver é recomendada para o seu hardware, use o comando:

$ ubuntu-drivers devices

Esse comando exibirá uma lista de drivers disponíveis e o driver recomendado para o seu sistema.

Instalar o Driver Recomendado

Substitua XXX pelo número da versão do driver recomendada (por exemplo, 560 ou outra) conforme indicado no passo anterior.

$ sudo apt install nvidia-driver-XXX

Durante a instalação, será solicitado que você crie uma senha para ativação do MOK (Machine Owner Key), necessária se o Secure Boot estiver ativado.

Ativar o Driver NVIDIA com Secure Boot

Após instalar o driver, reinicie o sistema:

$ sudo reboot

Quando o sistema reiniciar, será exibida a tela de gerenciamento MOK (Machine Owner Key). Siga estas instruções:

Selecione "Continue" para avançar no processo de inscrição da chave.

Escolha "Enroll MOK" para inscrever a nova chave.

Digite a Senha: Insira a senha que você configurou durante a instalação do driver.

Confirme a Inscrição: Siga as instruções para concluir a inscrição da chave.

Após essa etapa, o sistema aceitará os módulos do kernel assinados, permitindo o carregamento correto do driver NVIDIA mesmo com o Secure Boot ativado. Reinicie o sistema novamente para aplicar as alterações.

Verificar a instalação

Depois de reiniciar, use o comando abaixo para verificar se o driver está ativo:

$ nvidia-smi

Este comando deve exibir informações sobre a GPU NVIDIA, confirmando que o driver foi instalado corretamente.

Verificar o Estado do Secure Boot Para confirmar se o Secure Boot está habilitado, execute:

$ mokutil --sb-state

A saída deverá indicar "SecureBoot enabled" se o Secure Boot estiver ativo.

Feito!

Atenção: Mudanças no PIX a partir de Novembro! Verifique suas chaves

A partir de 1º de novembro de 2024, o sistema de pagamentos instantâneos PIX passará por mudanças significativas, com o objetivo de aumentar a segurança das transações e combater fraudes. O Banco Central do Brasil (BC) implementará novas regras que incluem limites para transferências realizadas a partir de dispositivos não cadastrados.

Mudanças no PIX

As principais alterações incluem:

• Limite de transferência: Para dispositivos que nunca foram usados para realizar transações Pix, o valor máximo por transação será de R$ 200, e o limite diário será de R$ 1.000. Para valores superiores, será necessário que o dispositivo esteja previamente cadastrado na instituição financeira.
• Cadastro de dispositivos: A exigência de cadastro se aplica apenas a novos dispositivos (celulares ou computadores) que nunca tenham sido utilizados para iniciar uma transação Pix. Dispositivos já cadastrados não sofrerão alterações nas regras.
• Medidas de segurança: As instituições financeiras deverão adotar soluções mais robustas para gerenciamento de fraudes e informar os clientes sobre cuidados necessários para evitar golpes. Além disso, elas devem verificar, pelo menos a cada seis meses, se os clientes têm registros de fraude.

Verificando as chaves PIX no registrato com conta Gov.BR

Para garantir a segurança e a correta utilização do sistema PIX, é fundamental verificar as chaves cadastradas. O Registrato é uma ferramenta disponibilizada pelo Banco Central que permite aos usuários consultar suas chaves PIX e outras informações bancárias. A seguir, um passo a passo para realizar essa verificação utilizando sua conta Gov.BR.

Passo a Passo para verificar as chaves PIX

1. Acesse o Portal do Registrato

Registrato

2. Login com conta Gov.BR:

Faça login utilizando suas credenciais da conta Gov.BR. Se ainda não tiver uma conta, será necessário criar uma.

Caso você tenha uma conta, mas ainda não seja Prata ou Ouro, será necessário migrar de Bronze para Prata ou Ouro para acessar todas as funcionalidades.

3. Navegue pelas opções:

Após o login, você poderá acessar relatórios e consultar suas chaves PIX, entre outras informações financeiras.

4. Verifique os detalhes das chaves:

Dentro da seção de consulta, você verá uma lista das chaves Pix associadas à sua conta. Verifique se todas as informações estão corretas e se não há nenhuma chave que você não reconheça.

5. Atualize ou remova chaves se necessário:

Caso encontre chaves que não são mais utilizadas ou que você não reconhece, utilize as opções disponíveis para atualizá-las ou removê-las conforme necessário.

6. Salve ou imprima os resultados:

É recomendável salvar ou imprimir os resultados da consulta para futuras referências e para manter um registro da sua segurança financeira.

Considerações finais

Com as novas regras do PIX e a possibilidade de fraudes mais sofisticadas, verificar regularmente suas chaves cadastradas é uma prática essencial para garantir a segurança das suas transações financeiras. O uso do Registrato através da conta Gov.BR facilita esse processo e proporciona uma camada adicional de segurança ao seu uso do sistema Pix. Mantenha-se sempre informado sobre as atualizações e boas práticas recomendadas pelas instituições financeiras para proteger seus dados e recursos.

Referências

https://www.infomoney.com.br/minhas-financas/mudancas-no-pix-entram-em-vigor-no-dia-1o-de-novembro-saiba-novas-regras/

Feito!