Forem: Anderson Leite

Como instalar o pgAdmin 4 no Ubuntu (modo Desktop ou Web)

Anderson Leite — Thu, 03 Jul 2025 00:46:21 +0000

Quero deixar aqui registrado as etapas que realizei para instalar o pgAdmin 4 no meu PC que roda o Ubuntu. Este passo a passo serve tanto para consultas futuras quanto para ajudar quem estiver pensando em fazer o mesmo e está enfrentando dificuldades.

1. Instale as dependências necessárias

Atualize os pacotes do sistema e instale os pacotes requeridos:

sudo apt update
sudo apt install curl ca-certificates gnupg -y

2. Adicione o repositório do pgAdmin

Importe a chave GPG:

curl https://www.pgadmin.org/static/packages_pgadmin_org.pub | sudo gpg --dearmor -o /usr/share/keyrings/pgadmin.gpg

Adicione o repositório ao APT:

echo "deb [signed-by=/usr/share/keyrings/pgadmin.gpg] https://ftp.postgresql.org/pub/pgadmin/pgadmin4/apt/$(lsb_release -cs) pgadmin4 main" | sudo tee /etc/apt/sources.list.d/pgadmin4.list

Atualize novamente os pacotes:

sudo apt update

3. Instale o pgAdmin 4

Você pode escolher entre modo Desktop ou modo Web:

🔹 Modo Desktop (interface gráfica no sistema):

sudo apt install pgadmin4-desktop -y

🔹 Modo Web (acessado via navegador):

sudo apt install pgadmin4-web -y

4. (Se escolheu modo Web) Configure o pgAdmin Web

Após a instalação via modo Web, execute o script de configuração:

sudo /usr/pgadmin4/bin/setup-web.sh

O script solicitará as seguintes informações:

Email para login
Senha
Confirmação das configurações

Acesso via navegador:

Após a configuração, o pgAdmin ficará disponível em:

http://localhost/pgadmin4

✅ Dica: Se estiver utilizando em ambiente de produção, considere configurar SSL e autenticação adicional no seu servidor web para proteger o acesso ao pgAdmin.

Instalação do PostgreSQL no Ubuntu

Anderson Leite — Thu, 03 Jul 2025 00:35:53 +0000

Quero deixar aqui registrado as etapas que realizei para instalar o PostgreSQL no meu PC que roda o Ubuntu. Este passo a passo serve tanto para consultas futuras quanto para ajudar quem estiver pensando em fazer o mesmo e está enfrentando dificuldades.

1. Atualize os pacotes existentes

Antes de mais nada, é importante garantir que todos os pacotes do sistema estejam atualizados:

sudo apt update && sudo apt upgrade -y

2. Adicione o repositório oficial do PostgreSQL

Instale as dependências necessárias:

sudo apt install wget ca-certificates gnupg lsb-release -y

Adicione a chave pública do repositório:

wget --quiet -O - https://www.postgresql.org/media/keys/ACCC4CF8.asc | sudo gpg --dearmor -o /usr/share/keyrings/postgresql.gpg

Adicione o repositório à lista de fontes do APT:

echo "deb [signed-by=/usr/share/keyrings/postgresql.gpg] http://apt.postgresql.org/pub/repos/apt $(lsb_release -cs)-pgdg main" | sudo tee /etc/apt/sources.list.d/pgdg.list > /dev/null

3. Atualize o APT e instale o PostgreSQL

Agora, com o repositório adicionado, atualize novamente o APT e instale o PostgreSQL com seus componentes adicionais:

sudo apt update
sudo apt install postgresql postgresql-contrib -y

4. Verifique se o serviço está ativo

Após a instalação, verifique o status do serviço PostgreSQL:

sudo systemctl status postgresql

Se tudo estiver funcionando corretamente, você verá algo como:

active (exited)

active (running)

5. Acesse o PostgreSQL via terminal

Troque para o usuário padrão do PostgreSQL:

sudo -i -u postgres

Acesse o prompt interativo do PostgreSQL:

psql

A saída esperada será:

postgres=#

Para sair do prompt:

\q

6. (Opcional) Criar um usuário e banco de dados

Você pode criar um novo usuário e um banco de dados com os comandos abaixo:

createuser --interactive
createdb nome_do_banco

⚠️ Nota: Este guia foi testado em Ubuntu e pode variar levemente dependendo da versão utilizada. Certifique-se de substituir nome_do_banco por um nome adequado ao seu projeto.

Conheça o Editor de Texto Online: Uma Ferramenta Minimalista para Todos os Usuários

Anderson Leite — Wed, 05 Mar 2025 12:57:37 +0000

Recentemente, lancei o Editor de Texto Online

O Editor de Texto Online é uma ferramenta gratuita, leve e intuitiva, que permite escrever, editar e exportar textos de forma prática – ideal para estudantes, profissionais e escritores casuais. Publicar este artigo no dev.to faz parte da estratégia para aumentar a autoridade e o ranqueamento do site, pois backlinks vindos de sites com alta relevância, como o dev.to, podem favorecer o SEO.

Por que essa estratégia ajuda no SEO?

Quando você publica conteúdo em plataformas reconhecidas e insere links para o seu site, como o Editor de Texto Online, os motores de busca interpretam isso como um sinal de relevância e autoridade. Além disso, links externos de alta qualidade ajudam a direcionar tráfego qualificado e reforçam a credibilidade do seu domínio. Essa prática, combinada com conteúdo de qualidade e otimização on-page, é fundamental para melhorar o ranqueamento nos resultados de busca.

O que é o Editor de Texto Online?

O Editor de Texto Online é uma ferramenta web desenvolvida para proporcionar uma experiência de edição simples e eficiente. Com uma interface minimalista, a ferramenta oferece recursos essenciais, como:

Edição e formatação intuitiva: Ideal para criar textos, resumos, artigos e documentos.
Exportação para PDF e DOCX: Facilita o compartilhamento e a publicação dos conteúdos.
Leve e responsivo: Compatível com diversos dispositivos, garantindo uma experiência fluida.
100% gratuito: Sem custos, para que todos tenham acesso às funcionalidades que realmente importam.

Vantagens de utilizar a ferramenta

Utilizar o Editor de Texto Online traz diversas vantagens, tais como:

Praticidade: Não é necessário instalar nenhum software – tudo é feito diretamente no navegador.
Versatilidade: Adequado para diferentes perfis de usuários, desde aqueles que precisam apenas anotar ideias até profissionais que produzem conteúdos para blogs e sites.
Performance: Por ser uma ferramenta leve, ela carrega rapidamente e se adapta a diversas condições de conexão.
Interface limpa e intuitiva: Foca apenas no que é essencial, evitando distrações e aumentando a produtividade na hora da escrita.

O que me levou a desenvolver a ferramenta

A ideia de criar o Editor de Texto Online surgiu a partir de uma necessidade pessoal e de observar lacunas em ferramentas de edição disponíveis no mercado. Durante minha trajetória como desenvolvedor e usuário, percebi que muitos editores eram sobrecarregados de funcionalidades e complexos para o uso cotidiano.

Queria algo que fosse rápido, simples e totalmente gratuito – uma ferramenta que atendesse tanto a quem precisa criar documentos simples quanto a profissionais que buscam uma solução prática para suas produções.

Essa experiência me motivou a desenvolver uma solução que unisse eficiência, minimalismo e usabilidade.

Como Melhorar seu Código Java: 7 Boas Práticas e Padrões de Desenvolvimento

Anderson Leite — Thu, 14 Nov 2024 16:09:49 +0000

Uma das coisas mais comuns (ou deveria ser) quando estamos desenvolvendo um projeto é se perguntar, quais são as boas práticas de programação que devemos utilizar. Seguindo esse contexto fiz um compilado de boas práticas que costumo seguir tanto nos meus projetos pessoais quanto no ambiente profissional.
Nas próximas linhas, vou explorar 7 boas práticas e padrões de desenvolvimento que sigo e me ajudam a escrever códigos melhores, melhorando não só a qualidade, mas também a minha produtividade e do time a qual integro.

1. Adote Convenções de Nomenclatura Consistentes

A consistência é uma das chaves para manter o código organizado e fácil de entender. Seguir convenções de nomenclatura ajuda a garantir que todos no time sigam um padrão claro, evitando confusões. Em Java, as convenções mais usadas incluem:

Classes e Interfaces: utilize PascalCase (exemplo: Usuario, Carro).
Métodos e Variáveis: a convenção mais adequada aqui é o camelCase (exemplo: calcularTotal, nomeCliente).
Constantes: para constantes, adote letras maiúsculas e separação por underscore (exemplo: TAMANHO_MAXIMO, VALOR_DEFAULT).
Pacotes: os nomes de pacotes devem ser escritos em letras minúsculas e seguir o padrão reverse domain name, ou seja, o nome do domínio invertido.

Esses padrões tornam o código mais fácil de ler e compreensível para qualquer desenvolvedor que trabalhe no projeto.

2. Aplique a Programação Orientada a Objetos (POO)

A programação orientada a objetos é um dos princípios fundamentais do Java, e adotar suas práticas adequadas pode fazer uma grande diferença no design do seu código. A POO permite uma melhor organização, reutilização de código e facilidade de manutenção. Algumas diretrizes incluem:

Encapsulamento: proteja os dados dentro de suas classes e permita que o acesso a esses dados seja feito apenas por meio de métodos controlados (GETs e SETs). Usar modificadores como private ou protected pode prevenir acessos indesejados.
Herança: embora útil, a herança deve ser usada com cautela para não gerar hierarquias complexas e difíceis de gerenciar. Prefira composição quando possível.
Polimorfismo: facilita a troca de comportamentos de objetos em tempo de execução, o que pode ser útil para tornar seu código mais flexível.

Seguir esses princípios ajuda a criar um código mais modular, o que facilita alterações e expansão no futuro.

3. Evite Redundância com o Princípio DRY (Don't Repeat Yourself)

A duplicação de código pode levar a erros e dificuldades em manutenção. O princípio DRY sugere que você deve evitar escrever o mesmo trecho de código várias vezes. Quando encontrar um padrão repetitivo, refatore-o para uma função ou classe reutilizável. Isso facilita a manutenção e reduz o risco de bugs.
Por exemplo, se você tem um código de validação de dados que se repete em várias partes do programa, considere extrair esse código para um método único ou até uma classe específica. Isso melhora a clareza e torna o código mais fácil de refatorar futuramente.

4. Comentários: Quando Usar e Quando Evitar

Comentários são uma ferramenta poderosa para explicar a lógica por trás de decisões difíceis de código, mas não devem ser usados para explicar o óbvio. Se o código é bem escrito e segue boas práticas de nomenclatura, ele deve ser autoexplicativo. Utilize comentários para:

Descrever decisões de design complexas.
Explicar por que uma abordagem foi escolhida quando não há uma solução clara.
Fornecer contexto adicional em casos que envolvem lógica complicada ou requisitos específicos.

Os comentários são importantes para explicar o "porquê" de uma decisão de código, mas não o "o quê" ou "como". -Blog: Cubos Academy

Evite comentar simplesmente para "explicar" o que uma linha de código faz — um bom código deve ser capaz de falar por si.

5. Testes Automatizados: Garantindo Qualidade do Código

Uma das melhores maneiras de garantir que seu código funcione corretamente é escrever testes automatizados. Eles ajudam a identificar problemas cedo, evitam regressões e melhoram a confiança na implementação. Os principais tipos de testes incluem:

Testes Unitários: testam unidades isoladas de código, como métodos ou funções. Utilizar ferramentas como JUnit pode automatizar esse processo.
Testes de Integração: avaliam a interação entre diferentes partes do sistema. São cruciais para garantir que o sistema como um todo funcione conforme o esperado.

Adicionar testes automatizados ao seu fluxo de trabalho pode parecer trabalhoso no início, mas a longo prazo, aumenta a eficiência e reduz o risco de falhas no código.

6. Gerenciamento Eficiente de Exceções

Lidar com exceções corretamente é crucial para garantir que seu software seja robusto e resiliente. Algumas dicas para um bom gerenciamento de exceções incluem:

Exceções Específicas: sempre que possível, lance exceções específicas em vez de utilizar Exception genéricas. Isso torna o código mais fácil de entender e depurar.
Evite Exceções Silenciosas: nunca capture uma exceção sem tratá-la adequadamente ou, pelo menos, logar a mensagem de erro. Ignorar exceções pode esconder problemas críticos no sistema.
try-with-resources: utilize essa abordagem ao trabalhar com recursos como arquivos e conexões de banco de dados. Ela garante que esses recursos sejam fechados automaticamente ao final do uso, evitando vazamentos de memória.

Ao seguir boas práticas de tratamento de exceções, seu código se torna mais confiável e fácil de manter.

7. Adote Padrões de Projeto (Design Patterns)

Design Patterns são soluções comprovadas para problemas recorrentes no desenvolvimento de software. Em Java, alguns padrões clássicos que podem ajudar a estruturar seu código de forma mais eficiente incluem:

Singleton: garante que uma classe tenha apenas uma instância e fornece um ponto global de acesso a ela.
Factory: permite a criação de objetos sem especificar a classe exata a ser instanciada. Isso facilita a extensão do código sem alterar as partes que dependem dessa criação.
Strategy: permite alterar o comportamento de um objeto em tempo de execução, sem modificar a classe que o utiliza. Esses padrões são valiosos para garantir que seu código seja escalável, flexível e fácil de entender.

Bônus: Utilize Ferramentas de Qualidade de Código em Java

Ferramentas de qualidade de código são fundamentais para identificar problemas no código antes que eles afetem o funcionamento da aplicação. Para projetos Java, considere utilizar as seguintes ferramentas:

Linters: analisam o estilo e a consistência do código, garantindo que ele siga as melhores práticas e convenções do Java (exemplo: Checkstyle).
Analisadores Estáticos: detectam potenciais erros, vulnerabilidades e problemas de desempenho sem a necessidade de execução do código (exemplo: SonarQube).
Formatadores Automáticos: asseguram que o código esteja sempre formatado conforme as convenções de estilo, como o padrão do Google Java (exemplo: Google Java Format).

Referencias utilizadas:

Testes Unitários com JUnit no Java

Anderson Leite — Thu, 21 Mar 2024 16:28:35 +0000

Os testes unitários estão sendo cruciais no meu dia a dia no desenvolvimento de software, garantindo que cada parte do código funcione como esperado. Percebo que no contexto da programação em Java, o JUnit é uma das ferramentas mais populares para escrever e executar testes unitários. Neste post quero explorar os conceitos básicos de testes unitários com JUnit, incluindo a configuração do ambiente de teste e os métodos mais comuns encontrados em testes unitários.

Configuração do Ambiente de Teste

Antes de começar a escrever testes, é necessário configurar o ambiente de teste. Isso geralmente envolve adicionar as dependências do JUnit ao seu projeto. Se você estiver usando Maven ou Gradle, pode adicionar a dependência do JUnit ao seu arquivo pom.xml ou build.gradle, respectivamente.

Maven

Para Maven, adicione o seguinte ao seu pom.xml:

<dependencies>
    <dependency>
        <groupId>junit</groupId>
        <artifactId>junit</artifactId>
        <version>4.13.2</version>
        <scope>test</scope>
    </dependency>
</dependencies>

Gradle

Para Gradle, adicione a seguinte linha ao seu build.gradle:

dependencies {
    testImplementation 'junit:junit:4.13.2'
}

Quando se trabalha com Spring Boot, uma das vantagens é a facilidade de configuração e execução de testes unitários e de integração. O spring-boot-starter-test é um starter que inclui todas as dependências necessárias para testar aplicações Spring Boot, incluindo JUnit, Mockito, AssertJ, entre outras ferramentas úteis para testes. Mas esse é assunto para outro post, que pretendo explorar um pouco mais sobre esse starter.

Escrevendo Testes Unitários

Um teste unitário é uma função que verifica o comportamento de uma parte específica do código, como um método ou uma classe. No JUnit, os testes são escritos como métodos públicos anotados com @Test.

Exemplo de Teste Unitário

Aqui está um exemplo simples de um teste unitário para uma classe Calculadora:

import org.junit.Test;
import static org.junit.Assert.assertEquals;

public class CalculadoraTest {

    @Test
    public void testSoma() {
        Calculadora calculadora = new Calculadora();
        int resultado = calculadora.soma(2, 3);
        assertEquals(5, resultado);
    }
}

Neste exemplo, o método testSoma verifica se o método soma da classe Calculadora retorna o valor esperado.

Métodos Comuns em Testes Unitários

Aqui está uma lista de métodos comuns que costumo utilizar em meus testes unitários com JUnit, juntamente com uma explicação resumida de cada um:

`assertEquals(expected, actual)`

Descrição: Verifica se dois valores são iguais. Se não forem, o teste falha.
Uso: Útil para comparar valores primitivos, objetos e arrays.

`assertTrue(condition)`

Descrição: Verifica se uma condição é verdadeira. Se não for, o teste falha.
Uso: Útil para verificar a validade de uma expressão booleana.

`assertFalse(condition)`

Descrição: Verifica se uma condição é falsa. Se não for, o teste falha.
Uso: Útil para verificar a invalidade de uma expressão booleana.

`assertNull(object)`

Descrição: Verifica se um objeto é nulo. Se não for, o teste falha.
Uso: Útil para verificar se um objeto não foi inicializado.

`assertNotNull(object)`

Descrição: Verifica se um objeto não é nulo. Se for, o teste falha.
Uso: Útil para verificar se um objeto foi inicializado corretamente.

`assertSame(expected, actual)`

Descrição: Verifica se dois objetos são o mesmo objeto. Se não forem, o teste falha.
Uso: Útil para verificar se duas referências apontam para o mesmo objeto na memória.

`assertNotSame(expected, actual)`

Descrição: Verifica se dois objetos não são o mesmo objeto. Se forem, o teste falha.
Uso: Útil para verificar se duas referências apontam para objetos diferentes na memória.

`assertArrayEquals(expected, actual)`

Descrição: Verifica se dois arrays são iguais. Se não forem, o teste falha.
Uso: Útil para comparar arrays de qualquer tipo.

`assertThat(actual, matcher)`

Descrição: Verifica se um objeto atende a uma condição especificada por um matcher. Se não atender, o teste falha.
Uso: Útil para verificações complexas e legíveis, utilizando a biblioteca Hamcrest para definir matchers.

`fail(message)`

Descrição: Faz o teste falhar imediatamente, com uma mensagem opcional.
Uso: Útil para indicar que um teste não deve ser executado ou para indicar um erro inesperado.

`assumeTrue(condition)`

Descrição: Ignora o teste se a condição for falsa.
Uso: Útil para evitar a execução de testes sob certas condições, como a presença de um recurso específico.

`assumeFalse(condition)`

Descrição: Ignora o teste se a condição for verdadeira.
Uso: Útil para evitar a execução de testes sob certas condições, como a ausência de um recurso específico.

Esses métodos são fundamentais para escrever testes unitários eficazes com JUnit, permitindo que verifiquemos o comportamento do código de maneira clara e concisa.

JUnit com outras ferramentas

Eh possível integrar o JUnit com outras ferramentas de testes para ampliar a funcionalidade e a eficiência dos testes unitários. Essa integração pode ser feita de várias maneiras, dependendo das necessidades específicas do projeto e das ferramentas desejadas. Aqui estão algumas maneiras comuns de integrar o JUnit com outras ferramentas de testes:

1. Mocking com Mockito

Mockito é uma biblioteca popular para criar e configurar objetos fictícios (mocks) em testes unitários. Ela pode ser usada em conjunto com o JUnit para isolar partes do código que estão sendo testadas, permitindo que você teste o comportamento de uma classe ou método sem depender de outras partes do sistema.

2. Assertions com AssertJ

AssertJ é uma biblioteca que fornece uma maneira mais legível e expressiva de escrever asserções em testes unitários. Ela pode ser usada em conjunto com o JUnit para melhorar a legibilidade e a clareza dos testes, tornando-os mais fáceis de entender e manter.

3. Testes de Integração com Spring Test

Para aplicações Spring Boot, o spring-boot-starter-test inclui o Spring Test, que fornece suporte para testes de integração e testes de controle de serviço. O Spring Test pode ser usado em conjunto com o JUnit para testar aplicações Spring Boot de maneira mais eficaz, aproveitando os recursos do Spring para configurar e executar testes.

4. Testes de Performance com JMeter

Embora o JMeter seja uma ferramenta separada para testes de performance, ele pode ser integrado com testes unitários escritos com JUnit para realizar testes de performance em aplicações Java. Isso permite que você teste o desempenho de suas aplicações em diferentes cenários e condições.

5. Testes de Interface do Usuário com Selenium

Selenium é uma ferramenta para testes de automação de navegadores da web. Embora seja mais comumente usada para testes de interface do usuário (UI), ela pode ser integrada com testes unitários escritos com JUnit para automatizar testes de UI e verificar a funcionalidade da interface do usuário.

6. Testes de Controle de Versão com Git

Embora o Git seja uma ferramenta de controle de versão e não uma ferramenta de teste, ele pode ser integrado com o processo de teste para garantir que apenas código que passa por todos os testes unitários seja commitado no repositório. Isso pode ser feito configurando o Git para executar os testes unitários antes de permitir que um commit seja feito.

Conclusão

Os testes unitários estão sendo fundamentais para garantir a qualidade do código e a correção de bugs dos projetos que venho desenvolvendo. O JUnit oferece uma ampla gama de métodos para verificar o comportamento do código, tornando-o uma ferramenta poderosa para testes unitários em Java. Ao escrever testes unitários, é importante cobrir todos os casos de uso possíveis para garantir que o código funcione como esperado em todas as situações.

Referências:

Como instalar Docker Compose no Linux

Anderson Leite — Mon, 12 Dec 2022 14:43:53 +0000

Nesse post quero compartilhar uma maneira de instalar o Docker Compose no Linux. Mas antes de colocar a mão na massa é interessante entender o que é o Compose e como ele funciona.

01 O que é Compose? E como funciona?

O Compose é uma ferramenta para definir e executar aplicativos Docker de vários contêineres. Com o Compose, você pode usar arquivos YAML para configurar os serviços do seu aplicativo. Então, com um comando, você pode criar e iniciar todos os serviços na configuração.

O Compose funciona em todos os ambientes: produção, preparo, desenvolvimento, teste, bem como fluxos de trabalho de CI. Ele também possui comandos para gerenciar todo o ciclo de vida do seu aplicativo:

Iniciar, parar e reconstruir serviços
Exibir o status dos serviços em execução
Transmita a saída de log dos serviços em execução
Executar um comando único em um serviço

02 Principais recursos

Os principais recursos do Compose que o tornam eficaz são:

03 Confira se o Docker esta instalado na sua máquina

Instalar a ferramenta Compose é fácil, mas primeiro certifique-se de ter o Docker instalado.

Rode esse comando no seu terminal para saber se o Doceker realmente esta instalado.

docker --version

Se não aparecer uma mensagem semelhante a esta Docker version 20.10.21, build baeda1f significa que você ainda não tem o Docker instalado, nesse caso eu publiquei este post mostrando: Instalação Completa do Docker no Ubuntu LTS, mas caso você esteja utilizando um sistema diferente, consulte o guia oficial.

04 Instale o Compose

Caso esteja utilizando alguma distribuição Linux, basta realizar a instalação com o seguinte comando:

sudo curl -L "https://github.com/docker/compose/releases/download/v2.5.0/docker-compose-$(uname -s)-$(uname -m)" -o /usr/local/bin/docker-compose

Os binários baixados da Internet não podem ser executados por padrão. Portanto, basta usar o programa chmod para aplicar permissões de execução (+x) ao binário que acabamos de baixar. Execute o seguinte comando em seu terminal:

sudo chmod +x /usr/local/bin/docker-compose

05 Verifique a instalação

Agora basta executar docker-compose --version para verificar a instalação. Se tudo correr bem, você deverá ver a seguinte saída (ou semelhante) em seu terminal:

docker-compose --version
# Docker Compose version v2.5.0

Você deve então ver os detalhes da versão instalada em seu terminal.

Para saber mais sobre o Compose (ou caso ocorra algum erro) basta consultar o guia oficial.

Referências:

Bônus:

Conheça o Editor de Texto, ferramenta online para trabalhar com textos de forma rápida e eficiente.

Instalação Completa do Docker no Ubuntu LTS

Anderson Leite — Fri, 02 Dec 2022 03:02:51 +0000

Nesse post quero compartilhar uma maneira de instalar o Docker no Ubuntu em 8 passos simples. Que nos dará acesso à sua interface de linha de comando (CLI).

Vamos aos passos

Desinstale versões anteriores
Instale as dependências iniciais
Adicione a chave pública do repositório Docker em sua máquina
Adicione o repositório remoto na lista do apt
Instale o Docker no Linux
Adicione seu usuário ao grupo de usuários Docker
Inicie o Daemon do Docker
Valide a instalação

Aqui, vamos fazer a instalação do Docker por meio do comando apt-get, considerando uma máquina com Ubuntu LTS 64-bit (amd64).

Se quiser ver as outras opções de instalação ou se estiver usando outro sistema operacional, consulte a documentação completa.

⚠️ Se você enfrentar algum problema ou comportamento diferente em algum dos passos, consulte o guia oficial.

Passo 1: Desinstale versões anteriores

Se você já possui uma versão do Docker instalada em sua máquina e deseja refazer o processo para atualizar ou corrigir um problema, primeiro remova os pacotes da versão que está na sua máquina.

Para fazer isso, use o seguinte comando no terminal:

sudo apt-get remove docker* containerd runc

Se nenhum dos pacotes estiver instalado, este comando retornará o erro E: Impossível encontrar o <nome-do-pacote>. Neste caso, é só prosseguir com a instalação.

Passo 2: Instale as dependências iniciais

Para permitir que o apt-get busque arquivos por HTTPS, instale os seguintes pacotes. Precisamos deles para prosseguir com a instalação:

sudo apt-get install \
apt-transport-https \
ca-certificates \
curl \
gnupg \
lsb-release

Passo 3: Adicione a chave pública do repositório Docker em sua máquina

Para adicionar a chave oficial GPG* do repositório Docker, execute o seguinte comando:

curl -fsSL https://download.docker.com/linux/ubuntu/gpg | sudo gpg --dearmor -o /usr/share/keyrings/docker-archive-keyring.gpg

⚠️ Essa etapa é necessária porque precisamos obter uma chave pública do servidor Docker Inc para garantir que todos os pacotes de dados obtidos da Internet sejam assinados com essa chave, evitando assim possíveis ataques à segurança.

Se tudo correr bem, você não terá nenhum feedback visual.

Passo 4: Adicione o repositório remoto na lista do `apt`

Para finalmente adicionar o repositório oficial do Docker no apt, execute o seguinte comando:

echo \
"deb [arch=amd64 signed-by=/usr/share/keyrings/docker-archive-keyring.gpg] https://download.docker.com/linux/ubuntu $(lsb_release -cs) stable" \
| sudo tee /etc/apt/sources.list.d/docker.list > /dev/null

Observe que adicionamos o repositório stable (em $(lsb_release -cs) stable), isto significa que teremos somente o repositório com as versões estáveis do Docker.

Em distribuições baseadas no Ubuntu, como o Linux Mint, pode ser necessário substituir o comando $(lsb_release -cs) por uma versão do Ubuntu compatível com esse sistema.
Exemplo: se você estiver usando o Linux Mint Tessa, altere o valor para bionic.

⚠️ Observação importante: não é garantido que o Docker seja executado em sistemas que não atendam aos requisitos do sistema operacional.

Passo 5: Instale o Docker no Linux

Agora, sim, vamos à instalação do Docker!

Primeiro, vamos garantir que os índices dos pacotes do apt estão atualizados, já que adicionamos um novo repositório:

sudo apt-get update

Entao vamos instalar a última versão estável do Docker Engine - Community, que é uma versão mantida pela própria comunidade, já que o Docker é open source. Para isso, execute no terminal:

sudo apt-get install docker-ce docker-ce-cli containerd.io

Passo 6: Adicione seu usuário ao grupo de usuários Docker

Para evitar o uso de sudo em todos os comandos Docker que formos executar, vamos dar as devidas permissões ao nosso usuário.

Primeiro crie um grupo chamado docker:

sudo groupadd docker

Caso apareça uma mensagem: groupadd: grupo 'docker' já existe, é só prosseguir.

Em seguida, adicione seu usuário a este novo grupo com o seguinte comando:

sudo usermod -aG docker $USER

⚠️ Atenção execute o comando exatamente como acima, com distinção entre maiúsculas e minúsculas.

Para ativar as alterações no grupo, você pode sair e fazer login novamente em sua sessão ou executar o seguinte comando no terminal:

newgrp docker

⚠️ Se você encontrar algum problema após executar este comando, reinicie seu dispositivo. Prossiga para a próxima etapa após reiniciar

Passo 7: Inicie o Daemon do Docker

O Daemon é um serviço que fica no background, ou seja, é um serviço que sempre está em execução e aguarda por comandos feitos por meio do CLI. Entretanto, para que este serviço fique sempre disponível, precisamos ativá-lo, até mesmo após reiniciarmos nosso computador.

Para consultar o status atual do daemon do Docker, execute o seguinte comando:

sudo systemctl status docker

O comando acima deve retornar um pequeno relatório sobre o serviço, incluindo seu status de execução:

● docker.service - Docker Application Container Engine
     Loaded: loaded (/lib/systemd/system/docker.service; enabled; vendor preset: enabled)
     Active: inactive (dead) since Thu 2022-11-23 19:35:27 -03; 2s ago
TriggeredBy: ● docker.socket
       Docs: https://docs.docker.com
    Process: 2034 ExecStart=/usr/bin/dockerd -H fd:// --containerd=/run/containerd/containerd.sock (code=exited, status=0>
   Main PID: 2034 (code=exited, status=0/SUCCESS

Caso o parâmetro Active esteja como stop/waiting ou, no nosso caso, como inactive, rode o comando start para iniciá-lo:

sudo systemctl start docker

Quando o status for consultado novamente, o processo deve estar como start/running/active.

Agora, vamos habilitar o daemon do Docker para iniciar durante o boot:

sudo systemctl enable docker

Passo 8: Valide a instalação

Para validar se tudo ocorreu como deveria na instalação, vamos executar o hello world do Docker:

docker run hello-world

O terminal deve retornar uma mensagem conforme o gif a seguir:

Tudo certo, temos o Docker instalado para utilizarmos! 🐋

Forem: Anderson Leite

Como instalar o pgAdmin 4 no Ubuntu (modo Desktop ou Web)

1. Instale as dependências necessárias

2. Adicione o repositório do pgAdmin

Importe a chave GPG:

Adicione o repositório ao APT:

Atualize novamente os pacotes:

3. Instale o pgAdmin 4

🔹 Modo Desktop (interface gráfica no sistema):

🔹 Modo Web (acessado via navegador):

4. (Se escolheu modo Web) Configure o pgAdmin Web

Acesso via navegador:

Instalação do PostgreSQL no Ubuntu

1. Atualize os pacotes existentes

2. Adicione o repositório oficial do PostgreSQL

Instale as dependências necessárias:

Adicione a chave pública do repositório:

Adicione o repositório à lista de fontes do APT:

3. Atualize o APT e instale o PostgreSQL

4. Verifique se o serviço está ativo

5. Acesse o PostgreSQL via terminal

Troque para o usuário padrão do PostgreSQL:

Acesse o prompt interativo do PostgreSQL:

Para sair do prompt:

6. (Opcional) Criar um usuário e banco de dados

Conheça o Editor de Texto Online: Uma Ferramenta Minimalista para Todos os Usuários

Recentemente, lancei o Editor de Texto Online

Por que essa estratégia ajuda no SEO?

O que é o Editor de Texto Online?

Vantagens de utilizar a ferramenta

O que me levou a desenvolver a ferramenta

Como Melhorar seu Código Java: 7 Boas Práticas e Padrões de Desenvolvimento

1. Adote Convenções de Nomenclatura Consistentes

2. Aplique a Programação Orientada a Objetos (POO)

3. Evite Redundância com o Princípio DRY (Don't Repeat Yourself)

4. Comentários: Quando Usar e Quando Evitar

5. Testes Automatizados: Garantindo Qualidade do Código

6. Gerenciamento Eficiente de Exceções

7. Adote Padrões de Projeto (Design Patterns)

Bônus: Utilize Ferramentas de Qualidade de Código em Java

Testes Unitários com JUnit no Java

Configuração do Ambiente de Teste

Escrevendo Testes Unitários

Métodos Comuns em Testes Unitários

assertEquals(expected, actual)

assertTrue(condition)

assertFalse(condition)

assertNull(object)

assertNotNull(object)

assertSame(expected, actual)

assertNotSame(expected, actual)

assertArrayEquals(expected, actual)

assertThat(actual, matcher)

fail(message)

assumeTrue(condition)

assumeFalse(condition)

JUnit com outras ferramentas

Conclusão

Referências:

Como instalar Docker Compose no Linux

01 O que é Compose? E como funciona?

02 Principais recursos

03 Confira se o Docker esta instalado na sua máquina

04 Instale o Compose

05 Verifique a instalação

Referências:

Bônus:

Instalação Completa do Docker no Ubuntu LTS

Passo 1: Desinstale versões anteriores

Passo 2: Instale as dependências iniciais

Passo 3: Adicione a chave pública do repositório Docker em sua máquina

Passo 4: Adicione o repositório remoto na lista do apt

Passo 5: Instale o Docker no Linux

Passo 6: Adicione seu usuário ao grupo de usuários Docker

Passo 7: Inicie o Daemon do Docker

Passo 8: Valide a instalação

Referências:

`assertEquals(expected, actual)`

`assertTrue(condition)`

`assertFalse(condition)`

`assertNull(object)`

`assertNotNull(object)`

`assertSame(expected, actual)`

`assertNotSame(expected, actual)`

`assertArrayEquals(expected, actual)`

`assertThat(actual, matcher)`

`fail(message)`

`assumeTrue(condition)`

`assumeFalse(condition)`

Passo 4: Adicione o repositório remoto na lista do `apt`