Com as tecnologias que constituem o cenário da programação em constante evolução, falar sobre boas práticas no desenvolvimento e manutenção de um software se torna cada vez mais relevante. Em um cenário como o atual, que aprecia a velocidade e a agilidade nas entregas das soluções tecnológicas, pode parece tentador sacrificar a clareza e organização do código em prol de uma entrega cada vez mais rápida. Entretanto, nessa corrida incessante, a importância de se ter um código limpo se mantém inalterada.

Apesar das ferramentas tecnológicas alterarem constantemente, o conceito do que pode ser um código limpo é atemporal, criar um código limpo não é em vão, considerando que ele é a base para se ter sistemas robustos e com fácil manutenção. Diante disso, existem alguns livros que abordam esse tema, dos quais trago aqui o livro: Código Limpo: Habilidades Práticas do Agile Software.

Este livro foi escrito por Robert C. Martin, também conhecido como o famoso Uncle Bob (Tio Bob), que aborda preocupações, princípios, práticas e padrões para garantir a existência de um código limpo no desenvolvimento de sistemas.

O livro inicia abordando o conceito do que é um código limpo. Traz definições segundo alguns autores, como o Bjarne Stroustrup, que também foi o criador do C++, ele afirma que:

A lógica de um código limpo deve ser direta para dificultar o encobrimento de bugs, as dependências devem ser minimas para facilitar a manutenção e finaliza enfatizando que o código limpo faz bem uma única coisa.

Um conceito que combina com todas as definições propostas e se alinha perfeitamente com a abordagem do livro é que o código para ser limpo, ele precisa ser feito por alguém que se importa.

Para o autor existem várias formas de se importar com o código e ele traz isso a partir de exemplos e práticas ao longo dos seguintes temas:

• Nomes significativos — Como criar nomes de variáveis, funções, parâmetros, classes entre outros que dê significado ao que está sendo proposto.
• Funções — Destaca que elas são a primeira linha de organização em qualquer programa e da ênfase em como podem ser melhor descritas.
• Formatação — Traz a importância da boa impressão que é causada quando se tem um código polido.
• Objetos e estruturas de dados — Aborda questionamentos sobre a utilização de métodos que expõe suas variáveis como se fossem públicas.
• Tratamento de erros — Ressalta técnicas e considerações para criar um código que seja limpo e robusto e ainda assim, trate erros com elegância e estilo.
• Limites — Apresenta técnicas para manter limpo os limites do software mesmo integrando com sistemas externos.
• Classes — Exemplifica e discute sobre como deixar uma classe limpa.
• Sistemas — Usa de analogias para facilitar o entendimento e aplicação dentro do desenvolvimento.

Além disso, ainda fala sobre emergência, concorrência, refinamento, JUnit, refatoramento, odores e heurísticas e muitos casos com exemplos práticos e análises específicas de uso.

Este livro não é um livro para se ler uma única vez e deixá-lo de lado, é um livro de cabeceira que vale a pena ser revisitado vez ou outra. O autor usa a linguagem em java para explorar cada exemplo mostrado, mas pode facilmente ser entendido e aplicado em outras linguagens.

Também vale destacar que o livro contempla várias fases do desenvolvimento de um software e da vida profissional do desenvolvedor, isso significa que os conceitos ali contidos vão com certeza acrescentar na vida de qualquer profissional, independente da sua experiência.

Você já leu esse livro? Se sim, qual capítulo mais te cativou? E por quê?

A relevância do desenvolvimento contínuo de um código limpo was originally published in sysvale on Medium, where people are continuing the conversation by highlighting and responding to this story.

Laravel é um framework PHP livre e open-source criado para o desenvolvimento de sistemas web que utilizam o padrão MVC e tem como principal característica, ajudar a desenvolver aplicações seguras e performáticas de forma rápida, com código limpo e simples.

Oi! Me chamo Hosana Barcelos e sou Desenvolvedora na Sysvale Softgroup. Esse artigo tem como objetivo mostrar como foi minha experiência com o Framework Laravel. Bora embarcar nessa viagem espacial?

Por diversas vezes passei olhando alguns arquivos PHP usando o Laravel e sempre saia deles com algumas (ou muitas) dúvidas sobre o funcionamento desse cara!

Fiz um projeto usando o Vue como SPA e o Laravel como API que cria e gerencia frases, para começar a entender como funciona o famoso Laravel e todo o seu fluxo. E como no fim tudo é CRUD, tinha que ser um CRUDzinho, né?

Apesar de ser um projeto básico e iniciante, dá pra absorver a base necessária para começar a usar o framework.

Requisitos

Para começar o desenvolvimento da API, foi importante entender as etapas necessárias. Primeiramente, é nececessário atender os requisitos básicos do framework conforme a documentação oficial do Laravel:

• PHP >= 7.2.5
• BCMath PHP Extension
• Ctype PHP Extension
• Fileinfo PHP extension
• JSON PHP Extension
• Mbstring PHP Extension
• OpenSSL PHP Extension
• PDO PHP Extension
• Tokenizer PHP Extension
• XML PHP Extension

Instalação

Após, foi necessário utilizar o gerenciador de pacotes composer para fazer a instalação do Laravel. Com o composer instalado e no diretório escolhido, bastou rodar o seguinte comando para começar a instalação:

composer create-project --prefer-dist laravel/laravel crud-laravel

E para iniciar o servidor, é só acessar o diretório que acabou de ser criado e rodar o comando:

php artisan serve

Informações do Banco

No diretório raiz onde o projeto crud-laravel foi criado, é possível visualizar um arquivo .env e é nesse arquivo que realizamos as configurações de ambiente. Essa parte requer atenção pois se as configurações do Banco de Dados não estiverem corretas, o projeto não funcionará como o esperado. As informações do meu Banco de Dados ficaram assim:

DB_CONNECTION=mysql
DB_HOST=127.0.0.1
DB_PORT=3306
DB_DATABASE=laravel
DB_USERNAME=root
DB_PASSWORD=

IPC: Caso você visualize o erro Access denied for user ‘root’@’localhost’ (using password: NO) no navegador, significa que você está tentando acessar a base de dados pelo usuário root sem informar a senha. Verifique no seu banco de dados qual a senha desse usuário e tente acessar a base com a senha.

Mais informações no link: https://pt.stackoverflow.com/questions/70151/erro-access-denied-for-user-rootlocalhost-using-passwordno-ao-aceder-a

Desenvolvimento

1. Para o começo do desenvolvimento, primeiro criamos um Model:

php artisan make:model Phrase -m

2. Após a criação do modelo, iremos criar as tabelas do banco no arquivo presente em database/migrations (o Laravel já possui algumas migrations nativas e é possível visualizá-las a partir do diretório citado). Essa tabela terá os atributos category e phrase:

3. Agora vamos criar efetivamente essa tabela em em nosso banco, rodando as migrations. E para isso, iremos utilizar o artisan com o seguinte comando:

php artisan migrate

Se as migrations foram rodadas com sucesso, podemos partir para a criação das rotas.

4. Para criarmos as rotas, iremos até o arquivo api.php presente em /routes/api.php. Criamos 5 rotas:

• Rota GET para listar as frases;
• Rota POST para adicionar uma nova frase na lista;
• Rota GET para retornar os dados de uma frase específica;
• Rota PUT para editar uma frase;
• Rota DELETE para excluir uma frase.

5. Após a criação das rotas, iremos criar o Controller com o seguinte comando:

php artisan make:controller PhraseController

6. Dentro do Controller (presente no diretório Http/Controllers/PhraseController.php) iremos criar nossas funções para os métodos vistos anteriormente.

Após a criação dos métodos, nosso back-end está pronto e tudo já pode ser testado! Para visualizar a interação com os métodos, precisei integrar o back-end ao front-end com ajuda do Axios. Você pode ver o consumo da API e criação dos métodos no Vue através da pasta /app presente no repositório.

7. Ao acessar a rota de listagem, é possível visualizar todas as frases que foram cadastradas no banco:

Foi uma experiência interessante desenvolver um CRUD com Laravel pois consegui absorver o fluxo de funcionamento, tanto começando um projeto novo, quanto gerenciando um já existente. 🚀

O projeto está disponível no GitHub e você consegue acessar por esse link: https://github.com/hosanabarcelos/crud-laravel.

Você pode acompanhar o escritor em outras redes acessando hosana.me.

Fazendo um CRUD e conhecendo o Laravel was originally published in sysvale on Medium, where people are continuing the conversation by highlighting and responding to this story.

Todos os arquivos criados em contêiner são armazenados na camada gravável do contêiner. Isso significa 3 coisas:

• Os dados não persistem quando o contêiner deixa de existir, e pode ser difícil extrair os dados do contêiner se outro processo precisar deles.
• A camada gravável de um contêiner está intimamente ligada à máquina host onde o contêiner está sendo executado. Não é fácil mover os dados para outro local.
• Escrever na camada gravável de um contêiner requer um driver de armazenamento para gerenciar o filesystem. O driver de armazenamento fornece um filesystem de união, usando o kernel do Linux. Essa abstração adicional reduz o desempenho em comparação com o uso de volumes, que escrevem diretamente no filesystem do host.

O Docker nos fornece 2 alternativas para que possamos persistir os dados após o contêiner ser parado: volumes e bind mount.

Vamos ver como utilizar cada uma.

Persistindo dados com bind mount

Primeiramente, vamos precisar criar na sua pasta home, uma pasta chamada volume-docker.

No terminal, verifique se esta no home e crie a pasta com o seguinte comando:

mkdir volume-docker

Ou crie pelo gerenciador de arquivos do seu sistema. Em seguida, rodamos o comando:

docker run -it --mount type=bind,source="/home/<seu-usuario>/volume-docker",target=/app ubuntu bash

• — mount e type=bind = indicam que vamos fazer um mount do tipo bind
• target=/app = indica a pasta dentro do contêiner onde iremos salvar os dados
• source = indica onde os dados serão persistidos
• ubuntu = é image que usaremos para criar o contêiner
• bash = vai abrir o shell do container em execução.

Quando o shell do bash abrir iremos executar o comando

cd app/

após essa etapa iremos criar um arquivo executando o comando

touch arquivo-qualquer.txt

Se abrirmos o gerenciador de arquivos e navegarmos até pasta volume-docker, conseguiremos visualizar o arquivo “arquivo-qualquer.txt” que foi criado.

Podemos sair do shell pressionando CTRL + D.

Vamos criar um novo contêiner rodando o seguinte comando:

docker run -it --mount type=bind,source="/home/<seu-usuario>/volume-docker",target=/app ubuntu bash

Agora, vamos para a pasta app

cd /app

Vamos executar em seguida

ls

Veja que o arquivo “arquivo-qualquer.txt” ainda existe, apesar de termos criado um novo contêiner e essa ser uma nova camada gravável. Ainda temos acesso ao arquivo criado. Se não fosse o bind mount, essa informação teria se perdido. Portanto, agora conseguimos persistir informações entre containers. Caso um contêiner pare de funcionar de alguma maneira e queiramos preservar os dados que estejam lá, já conseguimos fazer isso agora.

Persistindo dados com volume:

Quando utilizamos volumes, o próprio Docker vai fazer a gerência do nosso filesystem, o que faz com que ele seja mais confiável de utilizar.

Podemos criar volumes de 2 formas. A primeira é por utilizar o comando:

docker volume create meu-volume

podemos ver o volume criado rodando:

docker volume ls

Para utilizarmos esse volume podemos utilizar o comando:

docker run -it --mount source=meu-volume,target=/app ubuntu bash

Agora ele vai utilizar o meu-volume para armazenar as informações. Entrando no bash dele iremos executar:

cd /app

touch arquivo-qualquer-volume.txt

Após a execução, podemos observar que o arquivo “arquivo-qualquer-volume.txt” não é mais exibido no gerenciador de arquivos como anteriormente. Mas por que isso acontece? Porque nosso source (onde iremos salvar os arquivos) agora é o meu-volume.

Para acessar precisamos rodar os seguintes comando

sudo su

cd /var/lib/docker/volumes/meu-volume/_data

Isso acontece porque agora os arquivos são salvos em uma área do Docker e não no filesystem do dispositivo.

A 2 forma de criar é colocar o nome do novo volume já quando for executar, exemplo:

docker run -it - mount source=meu–novo-volume, target=/app ubuntu bash

Sobre o autor: Eduardo de Sá Lima é desenvolvedor estagiário na Sysvale Softgroup e cursa Licenciatura em Computação no IFSertãoPE.

Persistindo dados no Docker: Uma visão geral das opções was originally published in sysvale on Medium, where people are continuing the conversation by highlighting and responding to this story.

Para começarmos a falar sobre o eloquent vamos precisar de uma breve definição. Bem de forma simples, eloquent é um Object-Relational-Mapper (ORM) que vêm integrado ao Laravel. Por que ele é importante ? O eloquent busca facilitar a interação do Laravel com uma base de dados, permitindo estabelecer relacionamentos entre as tabelas e executar diversas operações como update, insert, delete.

Relacionamentos

Antes de começarmos vamos tornar o conceito de relacionamento mais claro. O que são relacionamentos? Os relacionamentos no banco de dados são associações estabelecidas entre tabelas. Como exemplo, no banco de dados existe uma tabela de Clientes e uma de Endereços onde é estabelecido que um cliente está associado a um endereço, para vincular as informações do cliente e endereço é criado um relacionamento entre essas tabelas.

No Laravel o Eloquent cria seus relacionamentos através de métodos, a construção de relacionamentos auxiliam a realização de query’s na base de dados.

Os tipos de relacionamentos explorados nesse artigo serão:

• Um para um (One to One)
• Um para Muitos (One to Many)
• Muitos para muitos (Many to Many)

Um pra um

O relacionamento “um pra um” e a forma mais básica de relacionamento, onde define a relação que um item possui um outro item. Para exemplificar utilizaremos o exemplo anterior, onde temos uma tabela de clientes e endereços, em que cada cliente vai estar associado a um endereço. E como seria isso no Laravel com Eloquent?

Primeiramente criamos suas respectivas tabelas, vamos optar por executar o comando de criação de model com a opção -m, pois assim será criado uma migração para o model em questão.

php artisan make:model Client -m

php artisan make:model Address -m

Adicionamos a chave externa da tabela de Cliente (Foreign Key) na tabela de migração Endereço e executamos a migração.

<?php
 
use Illuminate\Database\Migrations\Migration;
use Illuminate\Database\Schema\Blueprint;
use Illuminate\Support\Facades\Schema;
 
class Address extends Migration
{
    /**
     * Run the migrations.
     */
    public function up(): void
    {
        Schema::create('address', function (Blueprint $table) {
            $table->id();
            $table->string('name');
            $table->timestamps();

            $table->foreignId('client_id');
        });
    }
 
    /**
     * Reverse the migrations.
     */
    public function down(): void
    {
        Schema::drop('address');
    }
};

Após, devemos criar o relacionamento na tabela de Cliente, criando o método e utilizando o hasOne para indicar que a tabela de cliente possui um endereço.

public function address(): HasOne
{
    return $this->hasOne(Address::class);
}

Devemos então adicionar a logica reversa do relacionamento na tabela de endereços. Para isso criamos o método e utilizamos o belongsTo para indicar que o endereço pertence a um cliente.

public function client(): BelongsTo
{
    return $this->belongsTo(Client::class);
}

Um para muitos

Outro relacionamento importante a ser explorado é o “um para muitos”, onde define a relação que um item possui muitos outros itens. Seguindo o exemplo que estabelecemos, podemos definir que um cliente possa realizar vários pedidos. A aplicação e similar ao relacionamento “um para um”.

Primeiramente, devemos criar a tabela de Pedidos.

php artisan make:model Order -m

Adicionamos a tabela de Cliente o método que define a relação de pedidos utilizando o hasMany, para indicar que um cliente possui vários pedidos.

public function orders(): HasMany
{
    return $this->hasMany(Order::class);
}

Aplicando a logica inversa do relacionamento a tabela de Pedidos. Para isso criamos o método e utilizamos o belongsTo para indicar que o pedido pertence a um cliente.

public function client(): BelongsTo
{
    return $this->belongsTo(Client::class);
}

Muitos para muitos

A relação “muitos para muitos” possui uma complexidade maior. O relacionamento define que um item pode ser relacionado a vários outros itens e vice-versa. Assim, voltando para o nosso exemplo, se temos pedidos e produtos, um pedido pode possuir vários produtos, entretanto um produto pode estar associado a vários outros pedidos.

E como lidaremos com as chaves externa nesse relacionamento? para esse relacionamento é necessário uma tabela intermediária, chamada de tabela pivô, que irá armazenar a chave externa da tabela de pedido e produto, com isso conseguimos relacionar cada pedido a um produto.

E como seria no Laravel? Primeiro criamos a migração da tabela pivô.

php artisan make:migration create_order_product_table --create=order_product

A seguir adicionamos as chaves externas das tabelas pedido e produto na migração da tabela pivô dentro do método up.

<?php
 
use Illuminate\Database\Migrations\Migration;
use Illuminate\Database\Schema\Blueprint;
use Illuminate\Support\Facades\Schema;
 
class CreateOrderProductTable extends Migration
{
    /**
     * Run the migrations.
     */
    public function up(): void
    {
        Schema::create('order_product', function (Blueprint $table) {
            $table->id();
            $table->string('name');
            $table->timestamps();

            $table->foreignId('order_id');
            $table->foreignId('product_id');
        });
    }
 
    /**
     * Reverse the migrations.
     */
    public function down(): void
    {
        Schema::drop('order_product');
    }
};

Seguimos criando a tabela de produtos e adicionamos o relacionamento na tabela de produtos utilizando o belongsToMany.

php artisan make:model Product -m

public function orders(): BelongsToMany
{
    return $this->belongsToMany(Order::class);
}

E por fim, adicionando o relacionamento na tabela de pedidos com o belongsToMany.

public function products(): BelongsToMany
{
    return $this->belongsToMany(Product::class);
}

Conclusão

Bem chegamos ao final desse artigo, nesse artigo procurei definir o Eloquent e os conceitos básicos de relacionamentos e como ele trabalha. Os relacionamentos explorados nesse artigo são os mais comuns e utilizados em conceitos básicos. Alguns exemplos comentam sobre migrações (migrations), o que não foi explorado nesse artigo, em caso de duvidas consulte: https://laravel.com/docs/10.x/migrations.

Espero que este artigo tenha lhe sido útil, torço para que continue buscando conhecimento no Laravel e se aprofundando no Eloquent.

Boa sorte na sua Jornada!

Explorando o Eloquent: Relacionamentos was originally published in sysvale on Medium, where people are continuing the conversation by highlighting and responding to this story.

Para garantir uma UX de qualidade, existem diversas técnicas e abordagens de pesquisa que podem ser utilizadas (chamamos de pesquisa de experiência). Neste artigo, iremos focar em uma das mais importantes e eficazes: os testes de usabilidade.

Como mencionado, existem outros tipos de técnicas para realizar pesquisas de experiência, como entrevistas, questionários e observação de campo, cada um com suas vantagens e desvantagens, necessitando que o pesquisador saiba ponderar e escolher qual é a melhor técnica para a sua problemática. No caso dos testes de usabilidade, eles se destacam por oferecerem uma abordagem prática e direta, além de serem capazes de revelar insights sobre a interação entre os usuários e um produto ou sistema, identificando problemas e oportunidades de melhoria.

Neste texto, vamos falar sobre a importância de testes de usabilidade, desde a sua preparação até a análise dos resultados. Discutiremos as etapas necessárias para realizar testes eficazes, como definir objetivos, preparar o ambiente, recrutar participantes e analisar os dados coletados cuidadosamente.

Para preparar um teste de usabilidade, é preciso fazer um plano detalhado. Esse plano nos ajuda a comunicar os detalhes do teste, as responsabilidades da equipe e definir a quantidade de recursos necessários. O plano deve ter o objetivo do teste, o perfil dos participantes, o cenário de uso, as tarefas que os usuários devem fazer, os critérios de avaliação e os resultados esperados. É necessário ter os recursos certos para fazer o teste, como equipamentos de gravação de vídeo, software de análise de usabilidade e um lugar para fazer o teste.

O escopo

Para definir o escopo, é muito importante que nos façamos as seguintes perguntas:

— Para quem é o produto?

— Quais são as necessidades que o produto atende?

— O produto é novo?

— O produto substitui algo existente ou complementa algo já disponível?

Essas perguntas são fundamentais para que possamos descrever o produto, compreender as suas funcionalidades, estabelecer seus objetivos com o teste e definir o público-alvo do produto. Para isso, é necessário descrever as funcionalidades do produto do ponto de vista do usuário, ou seja, considerar as situações em que o produto seria utilizado.

Recrutamento

Para obter resultados significativos nos testes de usabilidade, é importante selecionar os participantes corretos. Como principais ações nessa parte do planejamento, temos:

• Definir critérios: É necessário estabelecer critérios claros para selecionar os participantes e buscar levar em consideração idade, gênero e características específicas relacionadas à experiência e habilidades relevantes para seu produto ou serviço.
• Tamanho da amostra: Determinar o tamanho da amostra é essencial para obter insights confiáveis. No geral, um grupo de 5 a 8 participantes é o recomendado, sendo suficiente para identificar os principais problemas de usabilidade.

Criação das tarefas

É na criação das tarefas que descrevemos detalhadamente a execução do teste, incluindo o passo a passo, os dados a serem coletados, as métricas de sucesso e as tarefas a serem realizadas pelos usuários. Para isso, precisamos responder às seguintes perguntas:

— Quais ações as pessoas devem ser capazes de realizar com o produto?

— Quais são os passos envolvidos na interação dos usuários?

— Como avaliaremos se o produto atende às necessidades dos usuários?

— Quanto tempo é necessário para que o usuário conclua uma tarefa usando o produto?

Essas perguntas são de extrema importância na criação das tarefas do teste e nas métricas de avaliação, e respondê-las nos ajuda a compreender melhor o processo e evita que cometamos erros na idealização das atividades.

Para o momento de criação de atividades, é necessário que o pesquisador tenha em mente que as tarefas precisam ser específicas, não permitindo que haja ambiguidade na sua realização, que ela aborde cenários do mundo real e que tenha um objetivo claro a ser alcançado. A partir disso, podemos destacar alguns pontos desta etapa:

• Seja específico e realista: As tarefas devem ser claras e precisas, fornecendo instruções detalhadas sobre o que os participantes devem fazer. Evite tarefas vagas ou ambíguas que possam levar a interpretações errôneas.
• Aborde cenários do mundo real: Pense em cenários do mundo real em que os usuários podem se encontrar ao usar o produto ou serviço.
• Estabeleça metas e objetivos claros: Além de descrever a tarefa em si, forneça aos participantes metas e objetivos específicos a serem alcançados durante a execução da tarefa.
• Varie a complexidade das tarefas: Ao criar um conjunto de tarefas, varie a complexidade e a dificuldade delas. Inclua tarefas mais simples e diretas, bem como tarefas mais desafiadoras que exijam um maior conhecimento ou habilidade do usuário.
• Observe a sequência das tarefas: Outro ponto para se atentar é a ordem em que as tarefas serão apresentadas aos participantes. No geral, recomenda-se inicar com as tarefas mais simples e introdutórias, para que os participantes se familiarizem com o produto e ganhem confiança.

Lembre-se sempre de que as tarefas devem ser adaptadas ao contexto do produto/serviço. É interessante, também, testar com antecedência as tarefas com colegas ou pessoas que não estejam envolvidas no projeto para identificar possíveis problemas.

Análise dos Resultados

Após finalizar os testes de usabilidade, é hora de analisar os resultados e extrair ideias valiosas. E nesse momento da pesquisa, podemos dividir o trabalho mais uma vez, criando um passo a passo para uma análise mais precisa e adequada. No processo de análise, é importante que os dados estejam bem organizados, pois o teste de usabilidade pode criar uma enxurrada de informações e nós podemos nos perder nelas se não tivermos cuidado. Assim, toda a organização desses dados vai tornar mais fácil o trabalho seguinte, de identificação de padrões e geração de insights.

• Passo 1: Organize os dados - Comece por oganizar todas as informações coletadas durante os testes. Isso inclui anotações, gravações em vídeo, capturas de tela e respostas dos participantes a questionários ou entrevistas pós-teste. Certifique-se de ter todas as informações necessárias disponíveis para análise.
• Passo 2: Identifique padrões - Procure por padrões e tendências nos dados coletados e observe quais problemas ou dificuldades foram relatados por vários participantes. Identifique pontos em comum nas interações dos usuários e faça anotações sobre problemas que se repetem.
• Passo 3: Priorize os problemas - Classifique os problemas identificados com base em seu impacto na experiência do usuário. Determine quais problemas têm maior urgência e devem ser corrigidos imediatamente.
• Passo 4: Gere insights - Analise os dados de forma a extrair insights e compreenda as motivações e necessidades dos usuários. Busque sempre entender o contexto por trás dos problemas e como eles afetam a experiência do usuário.
• Passo 5: Compartilhe os resultados - Una todas as descobertas e novas ideias em um relatório claro e conciso para ser apresentado aos membros da equipe responsável pelo projeto. Nessa apresentação, destaque os principais problemas e forneça recomendações para melhorias.

Conclusão

Os testes de usabilidade são essenciais para compreender e melhorar a experiência do usuário em produtos e serviços. Ao planejar e executar um teste de forma adequada, as equipes podem obter ideias sobre como os usuários interagem com o produto, além de identificar possíveis problemas de usabilidade.

Embora existam diversas outras técnicas de pesquisa de UX disponíveis, os testes de usabilidade se destacam por sua abordagem prática e direta. Eles permitem que os usuários reais interajam com o produto, revelando informações valiosas que não seriam obtidas apenas por meio de entrevistas ou questionários, por exemplo.

Portanto, ao projetar e desenvolver produtos e serviços voltados para os usuários, tenha em mente a poderosa ferramenta que os testes de usabilidade são. Analise se, para o seu produto, é um método que faz sentido e pode trazer as repostas que você precisa.

Sobre o autor: João Paulo Castro é UX/UI Designer na Sysvale Softgroup, tem formação em Engenharia da Computação pela Universidade Federal do Vale do São Francisco e é pós-graduando em Ciência de Dados pela UNAMA.

Testes de usabilidade na pesquisa de experiência was originally published in sysvale on Medium, where people are continuing the conversation by highlighting and responding to this story.

O Laravel é muito mais do que apenas um framework de desenvolvimento de aplicações web em PHP. Ele se destaca pela sua robustez e pela ampla gama de ferramentas que oferece, permitindo que os desenvolvedores escrevam códigos de forma moderna, elegante e seguindo as melhores práticas da programação.

O objetivo deste artigo é de auxiliar principalmente os desenvolvedores iniciantes, fornecendo dicas valiosas para que eles possam explorar mais o potencial do Laravel e aproveitar ao máximo suas ferramentas, fazendo com que olhem para o Laravel com uma nova perspectiva e se sintam confiantes ao utilizá-lo de maneira adequada.

Ao longo deste texto, vou compartilhar conhecimentos e experiências para que você possa aprimorar suas habilidades no desenvolvimento com Laravel. Abordaremos algumas dicas, passando por recursos essenciais do framework.

Sabemos o quão apaixonados somos pelo Laravel e entendemos o impacto que ele tem na nossa produtividade e na qualidade dos nossos projetos. Portanto, vamos abordar dicas que vão impulsionar sua produtividade, melhorar a eficiência do seu código e elevar a qualidade das suas aplicações Laravel.

Dica 1: Utilize arquivos de rotas separados

Quem já utilizou o Laravel seja para criar uma aplicação web ou api, sabe que facilmente um arquivo de rotas começa a ficar muito grande, e isso acaba tornando a manutenção e o trabalho mais difícil.

Um exemplo simples é: quem nunca criou uma rota e quando foi testar a rota ela estava dando um problema que não fazia sentido nenhum e ao final você se dá conta que o problema é que existia uma rota que tinha sido declarada previamente, que sua estrutura era muito parecida ou de nome igual, e a requisição ao invés de cair na sua rota estava caindo em outra rota que não tinha nada a ver? Pois é, essa é uma das situações que um arquivo lotado de rotas pode ocasionar. Para isso o Laravel nos dá a possibilidade de separar nossas rotas em arquivos diferentes.

E como podemos fazer isso? Temos duas formas:

1 — Adicionando os caminhos dos arquivos de rota no app/Providers/RouteServiceProvider.php :

No método boot é possível encontrar um trecho de código da seguinte forma:

Route::prefix('api')
    ->middleware('api')
    ->namespace($this->namespace)
    ->group(base_path('routes/api.php'));

Route::middleware('web')
    ->namespace($this->namespace)
    ->group(base_path('routes/web.php'));

Se você quiser adicionar múltiplos arquivos de rota nas rotas “web”, você pode passar no método group uma closure:

Route::middleware('web')
    ->namespace($this->namespace)
    ->group(function() {
	require base_path('routes/users.php');
	require base_path('routes/products.php');
    });

2 — Adicionando os caminhos dos arquivos de rota no próprio web.php ou api.php:

Este método é o mais simples, basta apenas adicionar o seguinte trecho ao final do arquivo:

Route::prefix('users')->group(base_path('routes/users'));
Route::prefix('products')->group(base_path('routes/products'));

Neste caso é necessário declarar um prefixo antes, com isso todas as rotas de users virão com users/{path da rota}, da mesma forma que o nome da rota também receberá o prefixo, por exemplo:

Se eu tenho a rota em routes/users.php:

// users.php
Route::get('posts', [PostController::class, 'index'])->name('index');

Ao adicionar no arquivo de rotas com o prefixo users eu terei:

• path: users/posts
• name: users.index

Dica 2: Utilize form request ao invés de validação no controller

O Form Request no Laravel é uma funcionalidade que permite validar os dados recebidos de uma requisição HTTP antes que eles sejam processados pelo controlador. É uma forma de centralizar e organizar as regras de validação em uma classe separada, conhecida como classe de Form Request.

Normalmente, ao lidar com formulários ou requisições de entrada de dados, é necessário validar os dados recebidos para garantir que eles atendam aos critérios desejados. O Laravel fornece várias maneiras de realizar essa validação, e uma delas é através do Form Request.

Utilizar o form request traz uma série de vantagens, como: a separação de responsabilidades, reutilização das regras de validação, centralização das regras de validação, validação automática, melhor segurança e facilidade de personalização.

Não é intuito deste artigo explicar em detalhes o funcionamento do form request, porque ele possui muitas ferramentas e essas informações estão disponíveis na documentação. Dito isto vamos trazer um exemplo simples de utilização:

Vamos supor que você tenha uma página de cadastro de usuários, e você enviará informações do usuário ao qual se deseja cadastrar para o back através de uma requisição POST, estes dados chegarão no Laravel através do Request, porém sem o form request eles chegarão ao controller sem validação alguma, normalmente faríamos:

public function store(Request $request)
{
    $validated_data = $request->validate([
        'name' => 'required|string|max:255',
        'email' => 'required|email|unique:users',
        'password' => 'required|string|min:6',
    ]);
    
    if ($validated_data) {
        // ...
    }
}

Apesar de funcional, esta não é uma boa prática e podemos melhorar este método para que nosso controller fique bem mais enxuto, com o comando: php artisan make:request StoreUserRequest podemos criar uma classe FormRequest, que é uma classe semelhante a esta:

<?php

namespace App\Http\Requests;
use Illuminate\Foundation\Http\FormRequest;

class StoreUserRequest extends FormRequest
{
    public function authorize()
    {
        return true; 
        // Defina a lógica de autorização de acordo com suas necessidades
    }
  
    public function rules()
    {
        return [
            'name' => 'required|string|max:255',
            'email' => 'required|email|unique:users',
            'password' => 'required|string|min:6',
        ];
    }
}

Os método authorize e rules vêm por padrão ao criar um form request com o artisan. O método authorize pode ser utilizado para verificar por exemplo uma permissão para o usuário autenticado, se ele não tiver autorização o método retornará false, e a requisição retornará HTTP 403 Forbidden (Acesso Negado). Já o rules é onde você define as regras (para mais detalhes consulte a documentação).

Com isso, no nosso exemplo agora teremos:

public function store(StoreUserRequest $request)
{
    // se chegou aqui, os dados foram validados corretamente
}

Desta forma nós teremos um controller muito mais limpo e passamos a responsabilidade de validação para uma classe que só vai fazer a validação dos dados do usuário.

Estendendo um pouco mais nosso exemplo e melhorando ainda mais este método, podemos utilizar a técnica do model bind e adicionar os tipos dos parâmetros e do retorno:

public function store(StoreUserRequest $request, User $user): UserResource
{
    $new_user = $user->create($request->validated());
    return new UserResource($new_user); 
    // o resource será explicado na próxima dica
}

Dica 3: Utilize resources

Em alguns casos é comum não enviar por exemplo o id de um registro porque para o front ele não interessa, ou é comum fazer uma transformação em algum dado no front quando a gente poderia fazer essa transformação no back e deixar essa responsabilidade para apenas uma classe.

No Laravel, uma resource (recurso) é uma classe que permite estruturar e formatar os dados de um modelo para serem enviados como resposta em uma API ou em uma representação específica, como JSON. As resources são usadas para transformar os dados do modelo em um formato adequado para a saída.

Quando usar o resource? Em cenários em que você precise transformar e formatar os dados do seu modelo para serem retornados como resposta em uma API ou em uma representação específica.

Qual tipo de resource eu devo utilizar?

Você quer retornar do controller um registro ou um conjunto de registros?

• Retornando apenas um registro: com o seguinte comando artisan é possível criar um resource: php artisan make:resource UserStoreResource

A classe gerada será semelhante a esta:

<?php

namespace App\Http\Resources;
use Illuminate\Http\Resources\Json\JsonResource;

class UserStoreResource extends JsonResource
{
    public function toArray($request)
    {
        return [
            'id' => $this->id,
            'name' => $this->name,
            'email' => $this->email,
            'created_at' => $this->created_at,
            'updated_at' => $this->updated_at,
        ];
    }
}

No método toArray é possível especificar os atributos que quer retornar, e também é possível alterar o nome deles se for o interesse. Nessa etapa também é possível fazer transformações nos dados como por exemplo no nome do usuário:

return [
   'id' => $this->id,
   'name' => strtoupper($this->name),
   'email' => $this->email,
   'created_at' => $this->created_at,
   'updated_at' => $this->updated_at,
];

Utilizando o resource criado no controller (lembre-se de importar a classe):

public function store(UserStoreRequest $request): UserStoreResource
{
    $user = User::create($request->validated());
    return new UserStoreResource($user);
}

// ou de forma alternativa se preferir, você pode utilizar o método 
// statico da classe JsonResource, o make()
return UserStoreResource::make($user);

• Retornando uma coleção de registros:

Para retornar uma coleção de registro, ao invés de utilizar o resource que estende a classe JsonResponse, utilizaremos o resource collection que estende a classe ResourceCollection. Podemos criar uma resource collection da mesma forma pelo artisan: php artisan make:resource UserCollection

O artisan é inteligente o suficiente para entender (se você nomear suas classes seguindo as convenções do Laravel, neste caso se no nome da classe tiver “Collection”), que você está criando um resource do tipo collection e já adiciona a classe ResourceCollection ao invés de JsonResouce. Se por acaso você não queira seguir a convenção, você pode adicionar uma flag ao comando artisan: php artisan make:resource User --collection

Com isso você terá uma classe semelhante a esta:

<?php

namespace App\Http\Resources;

use Illuminate\Http\Resources\Json\ResourceCollection;

class UserCollection extends ResourceCollection
{
    public function toArray($request)
    {
        return [
            'data' => $this->collection->map(function ($user) {
                return [
                    'nome' => $user->nome,
                    'email' => $user->email,
                ];
            }),
        ];
    }
}

No contexto da classe UserCollection, $this->collection refere-se à coleção de recursos (usuários) que está sendo manipulada pela resource. É como se eu tivesse $user = User::all() e fizesse um map em $user→map(). Os métodos mais utilizados no resource collection são o map e o transform, a diferença principal entre map() e transform() é a forma como eles afetam os itens da coleção original:

1. map(): O método map() cria uma nova coleção a partir dos itens da coleção original, aplicando uma transformação a cada item. A coleção original permanece inalterada. O resultado é uma nova coleção com os itens transformados.
2. transform(): O método transform() modifica diretamente os itens da coleção original. Ele aplica uma transformação a cada item, modificando-os na própria coleção original. Não é criada uma nova coleção separada.

Portanto, a escolha entre map() e transform() depende do seu caso de uso específico e dos requisitos do seu código. Se você precisa modificar a coleção original diretamente, use transform(). Se você precisa retornar uma nova coleção com os itens transformados, sem modificar a coleção original, use map().

Como utilizar esse resource collection no controller:

public function store(): UserCollection
{
    $users = User::all();
    return new UserCollection($users);
}

// ou de maneira alternativa, também utilizando o método statico make
return UserCollection::make($users);

Mais um exemplo interessante para o dia dia: vamos supor que agora quero retornar todos os meus usuários com seus respectivos endereços, onde um usuário possui N endereços e um endereço pertence a um usuário. Vamos supor também que temos a seguinte query:

// pega todos usuários do tipo colaborador com seus respectivos endereços
$collaborators = User::whereType('collaborator')->with('address')->get();

Esta query vai me retornar todos os usuários colaboradores com seus respectivos endereços (o with é da técnica eager loading que veremos na dica 6).

Agora criando o resource:

<?php

namespace App\Http\Resources;
use Illuminate\Http\Resources\Json\ResourceCollection;
use App\Http\Resources\AddressResource;

class UserCollection extends ResourceCollection
{
    public function toArray($request)
    {
        return [
            'data' => $this->collection->map(function ($collaborator) {
                return [
                    'nome' => $collaborator->nome,
                    'email' => $collaborator->email,
		    'addresses' => AddressResource::collection($collaborator->address),
                ];
            }),
        ];
    }
}

Como um colaborador pode ter mais de um endereço, eu posso adicionar uma chave “addresses” e no seu valor adicionar um resource de endereço. Note que ao invés de utilizar um AddressCollection eu utilizei um AddressResource, porque a classe JsonResponse também possui um método estático chamado collection que pode ser utilizado para criar uma collection a partir de um resource. Assim, na minha saída eu teria algo assim:

"data": [
   {
      "nome":"fulaninho 1",
      "email":"fulanilho1@mail.com",
      "addresses":[
         {
            "rua":"tal",
            "numero":123
         }
      ]
   },
   {
      "nome":"fulaninho 2",
      "email":"fulanilho2@mail.com",
      "addresses":[
         {
            "rua":"tal 2",
            "numero":321
         },
         {
            "rua":"tal 3",
            "numero":555
         }
      ]
   }
]

Os resources do Laravel são uma ferramenta muito poderosa e você pode e deve utilizar em seus projetos. Existem várias coisas que podemos fazer em uma classe resource, portanto é sempre muito bem vindo explorar essas funcionalidades na documentação.

Dica 4: Utilize as collections

Se você já teve alguma experiência com PHP, especialmente sem o uso de grandes frameworks como o Laravel, é provável que esteja familiarizado com os métodos in_array, array_reduce, array_map, array_filter, array_keys, entre outros. Essas funções são nativas do PHP e não há problema em utilizá-las. No entanto, quando estamos trabalhando com o Laravel, que é uma framework robusta e completa, temos acesso a uma ferramenta poderosa chamada collections que são estruturas de dados poderosas que fornecem uma variedade de métodos para manipular e trabalhar com conjuntos de dados de forma concisa e expressiva. Então se o Laravel nos dá essa ferramenta, porque não utilizar, não é mesmo? Vamos explorar e aproveitar ao máximo das collections do Laravel, pois elas são incrivelmente úteis, e além de deixarem nosso código mais elegante, deixa com mais carinha de Laravel!

Uma vantagem incrível do Laravel é a ampla gama de métodos disponíveis nas collections. Embora não seja possível abordar todos os métodos aqui, é altamente recomendado explorar a documentação oficial do Laravel para descobrir a variedade de métodos que podem auxiliá-lo no desenvolvimento. Com certeza, você encontrará métodos úteis que atendam às suas necessidades.

Dica 5: Utilize injeção de dependência

No contexto do Laravel, a injeção de dependência refere-se à prática de fornecer as dependências necessárias para uma classe ou objeto, em vez de criar ou gerenciá-las internamente. Isso é feito por meio do mecanismo de injeção de dependência fornecido pelo contêiner de serviços do Laravel.

Ao usar a injeção de dependência, você pode aproveitar vários benefícios, como a modularidade, reutilização de código, testabilidade e flexibilidade. Ele ajuda a reduzir o acoplamento entre as classes e torna o código mais extensível e fácil de manter.

Exemplo de uso da injeção de dependência:

<?php

class ActivityController extends Controller
{
    // sem injenção de dependência:
    
    public function index()
    {
        $activity_service = new ActivityService();
	// ...
    }

    // com injeção de dependência
    public function index(ActivityService $activity_service):
    {
	/// ...
    }			
}

Embora as duas formas sejam corretas e funcionais, utilizar a injeção de dependência vai nos dá algumas vantagens como: desacoplamento de código, reutilização de código, testabilidade, manutenção simplificada, extensibilidade, código mais limpo e legível. Vamos para mais um exemplo:

<?php

class ActivityController extends Controller
{
    public function index()
    {
        $activity_repository = new ActivityRepository();
	return $activity_repository->get();
    }

    public function store(Request $request)
    {
        $activity_repository = new ActivityRepository();
	return $activity_repository->create($request->all());
    }			
}

Para melhorar este código eu posso utilizar um construtor:

class ActivityController extends Controller
{
    private ActivityRepository $activity_repository;

    public function __construct()
    {
        $this->activity_repository = new ActivityRepository();
    }

    public function index()
    {
        return $this->activity_repository->get();
    }

    public function store(Request $request)
    {
        return $this->activity_repository->create($request->all());
    }			
}

Assim já está bem bacana, mas pode ficar ainda melhor! Por isso utilizaremos a injeção de dependência:

class ActivityController extends Controller
{
    private ActivityRepository $activity_repository;

    public function __construct(ActivityRepository $activity_repository)
    {
        $this->activity_repository = $activity_repository;
    }

    public function index()
    {
        return $this->activity_repository->get();
    }

    public function store(Request $request)
    {
        return $this->activity_repository->create($request->all());
    }			
}

A dependência ActivityRepository é injetada no construtor através da injeção de dependência. Isso permite que a instância da classe ActivityRepository seja fornecida de fora, em vez de criar uma nova instância dentro do construtor. A injeção de dependência é preferível, pois torna o código mais flexível, testável e reutilizável.

Com essas melhorias, a classe ActivityController agora depende da abstração ActivityRepository em vez de uma implementação concreta específica. Isso permite que você substitua facilmente a implementação do repositório por outra, se necessário, e também torna a classe mais fácil de testar, pois você pode injetar um mock do repositório nos testes.

Extra: deixando nossa classe exemplo mais “gatinha” com a inicialização da propriedade no construtor (disponível a partir do php 8):

class ActivityController extends Controller
{
    public function __construct(
      private ActivityRepository $activity_repository
    ){}

    public function index()
    {
       return $this->activity_repository->get();
    }

    public function store(Request $request)
    {
        return $this->activity_repository->create($request->all());
    }			
}

Dica 6: Evite a query N + 1 com Eager Loading

Eager loading é um conceito do Laravel que se refere ao carregamento antecipado de relacionamentos entre modelos. No Laravel, quando você recupera um model que possui relacionamentos definidos, o framework carrega automaticamente os dados dos relacionamentos quando você acessa esses relacionamentos.

No entanto, quando você tem um cenário em que precisa recuperar vários modelos com seus relacionamentos, o carregamento automático de relacionamentos pode resultar em um problema conhecido como “N+1 queries”. Isso significa que o Laravel executará uma consulta para recuperar os models principais e em seguida, uma consulta adicional para cada modelo relacionado, resultando em um número excessivo de consultas ao banco de dados, por exemplo:

$users = User::all();

foreach ($users as $user) {
    echo "Usuário: " . $user->name . "\\n";
    
    // consulta adicional para cada post de cada usuário
    foreach ($user->posts as $post) {
        echo "Post: " . $post->title . "\\n";
    }
}

Para resolver esse problema e melhorar o desempenho, o Laravel oferece o eager loading. Com o eager loading, você pode carregar antecipadamente os dados dos relacionamentos associados aos modelos principais em uma única consulta, em vez de executar consultas separadas para cada relacionamento.

$users = User::with('posts')->get();

foreach ($users as $user) {
    echo "Usuário: " . $user->name . "\\n";
    
    foreach ($user->posts as $post) {
        echo "Post: " . $post->title . "\\n";
    }
}

Nesse exemplo, usamos o método with('posts') para carregar antecipadamente os posts relacionados aos usuários em uma única consulta. Dessa forma, o Laravel executará apenas duas consultas: uma para recuperar os usuários e outra para recuperar todos os posts relacionados. Isso evita o problema de "N+1 queries" e melhora o desempenho da aplicação.

Com o with, também é possível carregar vários relacionamentos antecipadamente:

$users = User::with(['posts', 'comments', 'profile'])->get();

O uso do eager loading é especialmente útil quando você tem uma grande quantidade de dados e relacionamentos complexos. Ele permite que você carregue antecipadamente os dados relacionados necessários de forma eficiente, reduzindo o número de consultas e melhorando o desempenho geral da aplicação.

Dica 7: Utilize o método chunk para lidar com grandes volumes de dados

O método chunk() do Laravel é utilizado para processar um grande conjunto de resultados de consulta em partes menores (chunks) em vez de recuperar todos os registros de uma só vez. Ele é útil quando você precisa realizar operações em lotes em grandes conjuntos de dados, evitando a sobrecarga de memória e melhorando o desempenho da sua aplicação.

Exemplo:

User::query()->chunk(100, function ($users) {
    // Processar os resultados da consulta
});

O primeiro parâmetro do método chunk é a quantidade de registros que quero pegar por lote, o segundo parâmetro é uma closure que recebe como parâmetro uma instância do conjunto de resultados (users) que contém os registros a serem processados em cada iteração.

Dentro da função de retorno do chunk(), você pode realizar qualquer operação que precise ser feita nos registros retornados. Por exemplo, você pode atualizar os registros, executar cálculos complexos ou realizar outras operações de processamento em lote.

Dica 8: Reduza o consumo de memória com o método cursor

O método cursor() do Laravel é usado para recuperar registros do banco de dados de forma eficiente e em um modo de "lazy loading" (carregamento sob demanda). Em vez de retornar todos os registros de uma só vez, o cursor() permite que você itere sobre os registros um por um, mantendo um consumo mínimo de memória.

Exemplo:

foreach (User::cursor() as $user) {
    // Processar cada usuário individualmente
    echo "Usuário: " . $user->name . "\\n";
}

Neste exemplo, estamos usando o cursor() para iterar sobre cada registro da tabela de usuários. A cada iteração, um único registro é recuperado do banco de dados e o loop é executado. Isso permite que você trabalhe com os registros de forma eficiente, sem carregar todos eles na memória de uma vez.

Certo, e qual a diferença de fazer esse cursor do exemplo a cima e fazer:

User::query()->chunk(1, function ($user) {
    echo "Usuário: " . $user->name . "\\n";
});

O resultado seria o mesmo, porém, o cursor() é mais apropriado quando você precisa iterar sobre registros individualmente com o mínimo consumo de memória, enquanto o chunk() é mais adequado para operações em lotes, mesmo que o tamanho do lote seja pequeno.

Este artigo apresenta algumas dicas e exemplos que tiveram um grande impacto na minha experiência como desenvolvedor Laravel. Embora eu tenha abordado apenas alguns pontos, tentei ser breve e objetivo. Gostaria de explorar mais algumas das dicas, mas o artigo ficaria muito grande. Espero que essas dicas sejam úteis para você e que você comece a enxergar o Laravel de uma maneira diferente, assim como aconteceu comigo. Vamos expandir nosso conhecimento e nos desafiar a explorar novas ferramentas e abordagens, abandonando o modo automático de programar. Acredito que isso nos ajudará a evoluir como desenvolvedores.

Sobre o autor: Meu nome é Rodrigo Barboza, sou estudante de Engenharia de Computação na Universidade Federal do Vale do São Francisco e desenvolvedor na Sysvale Softgroup.

Código organizado, elegante e de fácil manutenção: dicas de Laravel was originally published in sysvale on Medium, where people are continuing the conversation by highlighting and responding to this story.

Mergulhe no mundo do Metabase e desvende sua capacidade de transformar dados em insights valiosos. Explore as etapas essenciais, desde a instalação até a criação de dashboards personalizados, e descubra como essa poderosa plataforma de análise de dados pode ajudá-lo a extrair o máximo valor de suas informações.

O Metabase

O Metabase é uma ferramenta de Business Intelligence (BI) de código aberto que permite ao usuário visualizar e analisar seus dados de forma fácil e intuitiva. Também possui uma interface amigável para criação de dashboards interativos, consultas, relatórios e compartilhar insights.

Uma de suas principais características é a interface de arrastar e soltar, a qual permite que usuários não técnicos criem visualizações de dados facilmente. Pode-se criar gráficos, tabelas, mapas e outros tipos de visualizações com apenas alguns cliques.

Outra grande vantagem do Metabase é ser uma ferramenta de código aberto, o que significa que você pode baixar, instalar e personalizar de acordo com suas necessidades. Além de oferecer uma comunidade ativa de desenvolvedores e usuários que fornecem suporte e contribuem com recursos adicionais.

Disponibilização do Metabase

O Metabase é construído e empacotado como um arquivo Java JAR, portanto bastar ter o Java configurado na sua máquina para poder utilizar o sistema.

Além do Java JAR a própria equipe do Metabase também disponibiliza o sistema em Docker e Metabase Cloud. Para mais informações basta acessar a documentação oficial referente à instalação.

Conhecendo o banco de dados

Antes de falar sobre como explorar os dados vale frisar que o Metabase tem suporte a uma variedade de fontes de dados, dentre elas temos MySQL, PostgreSQL, SQL Server, MongoDB, Google Analytics, Amazon Redshift, Google BigQuery e muitas outras.

Em relação a explorar os dados o Metabase tem uma funcionalidade, chamada Explorar dados, que oferece uma interface amigável e interativa para explorar, filtrar, resumir e visualizar seus dados em tempo real, permitindo que você faça descobertas valiosas de forma rápida e intuitiva.

Ao selecionar esta funcionalidade você será direcionado para uma interface onde pode selecionar a fonte de dados desejada e explorar as tabelas e colunas disponíveis nessa fonte de dados. A partir daqui, você pode realizar diversas ações para explorar seus dados.

Criando dashboards

Antes de criar um dashboard é necessário criar os gráficos, as tabelas e os indicadores que a mesma possuirá. Para criar esses elementos o Metabase dispõe a funcionalidade Pergunta.

As Perguntas são uma funcionalidade que permite fazer consultas e obter respostas rápidas e interativas sobre os dados. São uma forma mais simplificada de interagir com os dados, onde você pode fazer perguntas de forma livre, usando termos comuns da linguagem cotidiana, e o Metabase fará o trabalho de traduzir essas perguntas em consultas compreensíveis pelos bancos de dados.

Mas caso o usuário queria criar consultas mais complexas ou nativas existe a funcionalidade Consulta nativa, ao optar por esta opção será mostrada uma tela na qual o usuário poderá fazer consultas via código.

A resposta de ambas, Perguntas e Consultas nativas, podem ser exibidas como tabelas, gráficos ou outros tipos de visualização, dependendo da natureza dos dados e da pergunta feita. Após obter o resultado desejado basta salvar sua pergunta.

Agora sim podemos criar nossas dashboards interativas utilizando os elementos salvos anteriormente. Para tal basta utilizar a interface arrasta e solta para posicionar os gráficos, tabelas e indicadores conforme desejado. Além disso também pode-se agrupar os elementos por seções, adicionar filtros e links externos.

Continua…

Sobre o autor: Meu nome é Genival Rocha Machado, sou formado em Engenharia da Computação pela Universidade Federal do Vale do São Francisco e pós-graduando em Data Science e Analytics pela USP/ESALQ e atualmente trabalho como Scrum Master na Sysvale Softgroup.

Descubra o poder do Metabase was originally published in sysvale on Medium, where people are continuing the conversation by highlighting and responding to this story.

Com o conhecimento adquirido fui motivado a escrever este artigo com a intenção de auxiliá-lo(a) na caminhada de aprendizagem a conceitos básicos sobre à Lógica da Programação para iniciantes. Ao longo desta leitura, você irá adquirir os principais conceitos fundamentais da programação e será capaz de entender pequenos comandos de programas utilizando a lógica de programação.

CAPÍTULO 1: O MUNDO DA PROGRAMAÇÃO

Segundo o levantamento feito pelo g1.globo.com o setor de Tecnologia deve gerar aproximadamente 420 mil vagas até 2025. Uma coisa que não é clara para muitos e talvez ainda não esteja claro na sua mente é que, uma das chaves para ingressar nesse mercado desafiador é definida por uma simples palavra “Qualificação”. Acredito que muitas empresas desejam que esta seja uma prática ou se torne comum para pessoas de diferentes idades.

E pensando nos avanços tecnológicos diversas empresas estão aderindo à políticas internas com foco em capacitação continua para seus colaboradores, desde adesão ou no desenvolvimento de plataformas que disponibilizam diversos cursos com apoio de vídeos, pdf, e-books, livros e muito mais. Posso dizer a você que sou prova viva disso, a empresa a qual faço parte, a Sysvale, me proporcionou a experiência de poder começar meus estudos nesse mundo de desenvolvimento ou como muitos dizem o mundo Dev.

Programar é basicamente ensinar uma máquina a resolver problemas, todos já resolvemos problemas e tomamos decisões diariamente, mesmo sem perceber. Um exemplo claro é: lembra aquela receita do bolo? Ou aquele passo a passo para você chegar ao seu trabalho? Ao programar, você organiza e compreende a maneira de como se resolve os problemas. Na verdade, você já toma decisões e realiza tarefas constantemente; programar é apenas ensinar uma máquina a fazer o mesmo.

A programação nada mais é que automatizar decisões e atividades através de instruções para que um dispositivo eletrônico consiga executar tarefas de forma automática. Quando você entende esse conceito, os códigos começam a fazer mais sentido. Para quem quer explorar o mundo da programação, entender o mundo da programação e seus conceitos e a base para a construção de programas de computador e entender como os programas funcionam e como desenvolvê-los de maneira eficiente. Neste artigo, iremos tratar o que é a lógica de programação, como ela funciona e apresentar alguns exemplos básicos.

CAPÍTULO 2: HISTÓRIA DA COMPUTAÇÃO

A história da computação é uma jornada fascinante vivida já a alguns anos. Os primeiros dispositivos de contagem até os sofisticados computadores que temos hoje, tais evoluções vem transformando o mundo. Cientistas, inventores e visionários desenvolveram tecnologias inovadoras ao longo do tempo que permitem o processamento de forma rápida das informações, automação de tarefas e conectividade universal. Podemos afirmar que os principais marcos dessa jornada nos mostram como os computadores se tornaram a força da nossa sociedade atual.

Através da tabela abaixo podemos mostrar de forma detalhada um pouco da evolução até os tempos atuais.

Tabela 1 — História da computação

Tais computadores ainda utilizam números para processar informações, mas agora não precisamos nos comunicar com eles apenas pelos números. Isso não significa que você precise ser um expert em matemática para trabalhar com computadores. Mas possa te falar que é necessário ter uma mente super aberta para melhorar o pensamento lógico, que é crucial na programação.

Evolução dos computadores:

Figura 1 — Evolução dos computadores

CAPÍTULO 3: LÓGICA DA PROGRAMAÇÃO

A lógica de programação é a maneira de organizar instruções de forma lógica e sequencial, permitindo a criação de algoritmos para solucionar problemas. Que requerem habilidades como pensamento estruturado, tomada de decisões, repetição de ações e manipulação de dados, com o objetivo de desenvolver soluções eficientes e funcionais. Tal habilidade é extremamente fundamental na programação, possibilitando que os programadores criem programas de computador de maneira clara, lógica e assertiva.

As informações que visualizamos na tela de um computador podem ser transformadas em uma sequência de “zeros” e “uns”. Porém, seria muito complicado se tivéssemos que escrever e modificar a linguagem dos computadores usando somente “zeros” e “uns”, como era feito no passado com os cartões perfurados lembram? Com isto, foram desenvolvidas as linguagens de programação. Ao contrário dos “zeros” e “uns”, essas linguagens utilizam palavras comuns que são mais fáceis de entender e trabalhar com elas. Por exemplo, o branco puro na tela pode ser representado como 11111111 e o número 8 como 1000. As linguagens de programação possuem suas próprias regras e boas práticas, tornando a comunicação entre as pessoas e o computador, assim como entre os programadores, mais simples e eficiente.

Você ainda pode se perguntar qual a diferença entre lógica de programação e linguagem de programação?

A lógica de programação é a maneira de estruturar e organizar instruções de maneira lógica e sequencial, com foco em resolver problemas, já a linguagem de programação são regras e símbolos somados para escrever as instruções de forma compreensível para o computador. Nada mais é que a lógica de programação é a capacidade de pensar e planejar a solução de um problema, independentemente da linguagem utilizada e a linguagem de programação é a ferramenta que permite expressar essa solução em um formato que o computador possa entender e executar.

Ter uma boa lógica de programação é essencial para criar algoritmos eficientes e solucionar problemas de forma lógica, independentemente da linguagem escolhida.

Sequência lógica é a ordem e a conexão coerente de eventos, ações ou instruções, seguindo uma lógica ou raciocínio específico. É a capacidade de organizar passos ou elementos de forma sequencial e coerente, garantindo que cada etapa esteja corretamente relacionada à próxima. Uma sequência lógica é fundamental na programação, pois permite que as instruções sejam executadas na ordem correta e que a lógica do programa seja seguida de maneira consistente.

A lógica pode ser definida como a maneira que usamos para analisar se uma proposição é verdadeira ou falsa. E essa é a sua principal aplicação na programação. Usamos letras do alfabeto para representar as proposições

P, Q, R.

• características obrigatórias de uma proposição:
• Sujeito definido
• Sentido completo
• Verbo
• Possibilidade de ser
• classificada em V ou F
• Não são proposições:
• Sentenças muito abertas
• Sentenças muito amplas
• Sentenças não objetivas

Os conectivos lógicos são operadores que permitem combinar proposições e construir expressões lógicas mais complexas. Os principais conectivos lógicos são:

• Conjunção (E): Representada pelo símbolo “E” ou “^”, a conjunção une duas proposições e só é verdadeira se ambas as proposições forem verdadeiras.
• Disjunção (OU): Representada pelo símbolo “OU” ou “∨”, a disjunção une duas proposições e é verdadeira se pelo menos uma das proposições for verdadeira.

Figura 2 — Conectivos Lógicos

• Disjunção exclusiva (→): “ou p, ou q” podemos dizer que é um conectivo lógico que retorna verdadeiro quando apenas uma das proposições é verdadeira e a outra é falsa. Se as proposições tiverem os mesmos valores de verdade, o resultado é falso. É frequentemente usado para verificar a exclusividade de opções em lógica e programação.
• Condicional (→): Representado pelo símbolo “se…então”, o condicional estabelece uma relação de implicação entre duas proposições. Se a primeira proposição é verdadeira, a segunda também deve ser verdadeira.

Figura 3 — Conectivos Lógicos

• Bicondicional (↔): Representado pelo símbolo “se e somente se”, o bi condicional afirma que duas proposições são verdadeiras ou falsas em conjunto. Ambas as proposições devem ter o mesmo valor de verdade para que o bi condicional seja verdadeiro.

Figura 4 — Conectivos Lógicos

CAPÍTULO 4: ORGANIZAÇÃO COMPUTACIONAL

Entendemos que a programação não apenas se concentra na criação de software, é essencial também compreender o hardware a parte física do computador. O primeiro passo consiste em compreender a organização de um computador, podemos dividir essa organização computacionais da seguinte maneira:

• Dispositivos de Entrada;
• Memórias;
• Unidade Central de Processamento (CPU);
• Armazenamento de dados;
• Dispositivos de Saída;

Figura 5 — Componente básicos de um computador

CAPÍTULO 5: O QUE SÃO ALGORITIMOS?

Algoritmos é um conjunto de instrução sequencial e lógicas que descrevem um procedimento, ou seja, um passo a passo para resolver um problema. Na programação eles são a base ou o ponto chave, permitindo que os desenvolvedores desenvolvam soluções eficientes e automatizadas. Os algoritmos podem ser expressos em linguagens de programação ou de forma mais genérica, usando pseudocódigo. Eles são essenciais para a resolução de problemas computacionais, fornecendo uma abordagem estruturada e organizada para a solução de tarefas simples ou complexas.

A descrição narrativa, o fluxograma convencional e o pseudocódigo são formas de como podemos representar os algoritmos vejamos a explicação detalhada e exemplos de cada um:

Descrição narrativa: é maneira de linguagem natural, onde as fases do algoritmo são descritas em sequência.

Fluxograma convencional: poderá ser utilizados símbolos e setas para visualizar o fluxo das instruções, ajudando de forma mais clara a entender a ordem e as possíveis decisões no algoritmo.

Pseudocódigo: é uma junção de linguagem natural com elementos de programação, possibilitando uma descrição mais detalhada das fases do algoritmo.

Vamos para prática:

programa {
  funcao inicio() {
    escreva("Olá, Mundo novo!")
  }
}

Nosso retorno em tela: Olá, Mundo novo!

Cada caso terá suas vantagens e qualquer uma delas poderá ser escolhida de acordo com as preferências e necessidade do programador. Fica a seu critério escolher de acordo com seu contexto específico, das habilidades e proximidade do programador, bem como da clareza e eficiência desejadas na comunicação do algoritmo.

CAPÍTULO 5: VARIÁVEIS E OPERADORES ARITMÉTICOS:

Variáveis constantes são espaços reservados na memória do computador que armazenam valores que não se alteram ao longo do tempo. Ao contrário das variáveis, que podem ser modificadas, as constantes possuem um valor fixo e não são alteradas durante a execução do programa. Por exemplo, o valor de PI é uma constante que não muda. Enquanto as variáveis representam espaços na memória que podem ser alterados, as constantes servem para armazenar valores estáticos e imutáveis.

Podemos dizer que a memória de um computador é o local onde os dados e programas são armazenados e existem dois tipos de memórias:

• Memória principal, que é aquela que guarda as informações usadas pelo sistema operacional e aplicativos.
• Memória secundária: que é utilizada para armazenar grandes volumes de dados. Exemplos de memória secundária incluem HDs, SSDs, pen drives e cartões Micro SD.

Para armazenar os dados, a memória funciona como um arquivo com várias gavetas, onde cada gaveta guarda um valor específico.

Tipos de dados:

Em uma memória de um computador, encontramos duas classificações: instruções e dados. As instruções são aquelas responsáveis por orientar o funcionamento de uma máquina e caracterizar como os dados irão ser processados. Por fim os dados são conjuntos de objetos que compartilham um comportamento em relação a um conjunto de operações específicas. Por exemplo, podemos ter dados que representam números ou caracteres, e as instruções indicarão como realizar cálculos ou manipular esses dados de acordo com as necessidades do programa.

Figura 7 — Tipos de dados

Operadores de atribuição e aritmético:

O operador de atribuição é usado para definir o valor de uma variável em um algoritmo ou programa. Ele é representado pelo sinal de igual (=), que indica que o valor à direita será aplicado à variável à esquerda. Por exemplo, ao escrevermos “x = 5”, estamos atribuindo o valor 5 à variável x. Essa operação é fundamental para armazenar e manipular dados durante a execução de um programa.

programa {
  funcao inicio() {
    x: inteiro
    x = 10 // Utilizando o operador de atribuição para definir o valor de x como 10
    escreva("O valor de x é: ", x)
  }
}

Nosso retorno em tela: O valor de x é: 10

Acredito que você lembre das expressões matemáticas que resolvíamos na escola, cheias de números e operadores como SOMA, SUBTRAÇÃO e MULTIPLICAÇÃO etc. Você sabe que na expressão 2 + 2 o sinal + é um operador que representa a soma. Correto? E sabe que essa expressão resulta no valor de (4). Procede? Então, você já entendeu o sentido dos operadores, assim devemos relacionar valores para resultar um outro valor.​

Existem 3 tipos de operadores: Aritméticos​, Lógicos​ e Relacionais​. Entender como funciona cada operador é muito importante para aprender programação mesmo que a representação simbólica possa variar entre as linguagens. Todos os programas utilizam operadores para realizar suas tarefas.

Operadores relacionais e lógicos:

Operadores relacionais são usados para comparar valores (de qualquer tipo), e dar como resultado de uma expressão relacional, ou seja, um valor booleano (VERDADEIRO ou FALSO). Representados por: igual​, diferente​, maior​, menor​, maior ou igual​, menor ou igual ​(Representados na tabela abaixo).

Não requer aqui explicar cada um, pois eles são autoexplicativos. Mas vale lembrar que para quem está iniciando em desenvolvimento de softwares, algumas informações podem ser importantes, principalmente pelo fato de haver diferença entre linguagens de programação se liga.

Tabela 3 — Operadores lógicos

Os Operadores lógicos também conhecido como operadores booleanos, são usados para combinar resultados de expressões relacionais e retornar um valor booleano, que pode ser verdadeiro ou falso. Esses operadores nos permitem ter opções de criar condições mais complexas quando lidamos com a programação, pois proporcionam a avaliação de múltiplas expressões e a tomada de decisões com base nesses resultados.

• O operador “e” retorna verdadeiro apenas se ambas as expressões forem verdadeiras.
• O operador “ou” retorna verdadeiro se pelo menos uma das expressões for verdadeira.
• O operador “não” inverte o valor de verdadeiro para falso e vice-versa.

Tabela 4 — Operadores lógicos

programa {
  funcao inicio() {
    real nota, frequencia
    escreva("Nota: ") leia(nota)
    escreva("Frequência: ") leia(frequencia)
    se (nota > 7 e frequencia >70){ escreva ("Aprovado.")
  }
}

Nosso retorno em tela:

Nota: 10

Frequência: 100

Aprovado.

CAPÍTULO 6: ESTRUTURAS DE DECISÃO E REPETIÇÃO

Podemos dizer que as estruturas de decisão foram criadas para gerir o fluxo e a execução de um programa com base em afirmações específicas, vejamos:

• A estrutura “SE” executa um bloco de código se uma condição for verdadeira.
• A estrutura “ENQUANTO” executa repetidamente um bloco de código enquanto uma condição for verdadeira.
• A estrutura “FAÇA-ENQUANTO” executa um bloco de código pelo menos uma vez e, em seguida, verifica se uma condição seja verdadeira para continuar executando ou não. Tais fluxos nos permitem criar programas mais dinâmicos e adaptáveis, controlando a execução com base em condições específicas.

Tabela 5 — Estrutura de decisão

Algumas possibilidades de como usar as estruturas:

se media < 10 entao
  escreva("Reprovado")

enquanto media < 10 entao
  escreva("Reprovado")

faca {
    escreva("Esse é meu resultado \n")
} enquanto nota1 <= 5

A lógica de programação é um pontapé inicial na área da programação, podemos dizer que é o alicerce inicial, é onde iremos desenvolver pequenas soluções simples e eficientes, no começo confesso que é de forma desorganizada as vezes de maneira meio confusa, mas à medida que formos praticando vamos entendendo e melhorando aos poucos. Um dia por vez, mas calma MACHO, com foco e determinação iremos entender os princípios básicos da lógica de programação, e nós vulgos iniciantes iremos adquirindo mais habilidades essenciais e continuaremos crescendo e aprendendo a resolver problemas e desenvolver melhores e novos algoritmos.

Em resumo, a lógica de programação é o ponto de partida crucial para qualquer pessoa iniciante na programação. Ela no auxilia com fundamentos necessários para construir algoritmos eficientes, desenrolando problemas e desenvolvendo as famosas habilidades de pensamento lógico. Com uma estrutura firme em lógica de programação, por fim nós meros iniciantes estamos designados á explorar diferentes linguagens de programação e aumentar nossos conhecimentos no campo da computação.

Deus abençoe.

Bons estudos!

REFERÊNCIAS

G1.GLOBO.COM/. Área de TI deve gerar quase 420 mil vagas até 2025, mas faltam profissionais. Disponível em: https://g1.globo.com/jornal-hoje/noticia/2023/03/13/area-de-ti-deve-gerar-quase-420-mil-vagas-ate-2025-mas-faltam-profissionais.ghtml. Acesso em: 12 mai. 2023.

CONQUERPLUS.COM.BR. Lógica de programação. Disponível em: https://www.conquerplus.com.br/search?keyword=L%C3%B3gica+de+programa%C3%A7%C3%A3o. Acesso em: 1 mai. 2023.

Lógica de programação para iniciantes was originally published in sysvale on Medium, where people are continuing the conversation by highlighting and responding to this story.

Salve guys!

Eu me chamo Edwildson e sou desenvolvedor na Sysvale. Estão prontos para continuar nessa jornada fascinante do Kubernetes? Se você não leu a parte 1 deste arquivo clique aqui para visualizá-lo.

Na primeira parte vimos como configurar o ambiente, criar clusters, implantar e gerenciar aplicações. Agora veremos como configurar recursos e técnicas avançadas, lidar com escalabilidade e tolerância a falhas, observar e monitorar o cluster.

Configuração e Gerenciamento de Recursos:

Ao utilizar o Kubernetes, é essencial entender como configurar e gerenciar os recursos que compõem sua infraestrutura e serviços.

1. Noções básicas sobre objetos Kubernetes:

• Pods, Services e Deployments: Se você chegou até aqui já deve saber o que são, então bora para os demais.
• ConfigMaps: Os ConfigMaps são objetos que permitem armazenar dados de configuração em formato de chave-valor. Eles são usados para injetar configurações em contêineres, evitando a necessidade de codificar configurações diretamente nos arquivos de imagem.
• Secrets: Os Secrets são objetos que fornecem uma maneira segura de armazenar e gerenciar informações sensíveis, como senhas, tokens de acesso e certificados. Eles são usados para proteger dados confidenciais em aplicativos e são frequentemente utilizados em conjunto com ConfigMaps.

2. Utilização de arquivos de manifesto YAML:

• O Kubernetes utiliza arquivos de manifesto YAML para descrever a configuração da infraestrutura e dos serviços. Esses arquivos contêm definições dos objetos Kubernetes, como Pods, Services, Deployments, ConfigMaps e Secrets.
• No arquivo de manifesto YAML, você especificará os detalhes de cada objeto, como nome, tipo, portas expostas, volume mounts e outras configurações relevantes.
• Depois de criar ou atualizar o arquivo de manifesto, você pode aplicá-lo ao cluster Kubernetes usando o comando kubectl apply -f <nome-do-arquivo.yaml>. O Kubernetes lerá o arquivo e fará as alterações necessárias na infraestrutura e serviços.

3. Configuração de redes, volumes e variáveis de ambiente:

• Configuração de redes: O Kubernetes oferece diferentes opções de configuração de redes para os Pods se comunicarem entre si e com o mundo externo. Isso inclui a configuração de serviços, DNS interno, políticas de rede e definição de endereços IP.
• Configuração de volumes: Os volumes no Kubernetes permitem que os contêineres acessem e armazenem dados de forma persistente. Existem vários tipos de volumes disponíveis, como Volumes vazios, PersistentVolumes (PVs) e PersistentVolumeClaims (PVCs), que fornecem diferentes níveis de persistência e compartilhamento de dados.
• Variáveis de ambiente: As variáveis de ambiente podem ser configuradas em contêineres Kubernetes para fornecer configurações específicas, como chaves de API, URLs de serviços e outras informações dinâmicas. Essas variáveis podem ser definidas no arquivo de manifesto YAML ou em ConfigMaps e Secrets.

Dominar a configuração e o gerenciamento de recursos no Kubernetes é essencial para aproveitar ao máximo essa plataforma. À medida que você ganha experiência, poderá explorar recursos mais avançados e personalizados para atender às necessidades específicas de sua aplicação.

Escalabilidade e Tolerância a Falhas:

A escalabilidade e a tolerância a falhas são aspectos cruciais ao executar aplicações no Kubernetes.

1. Dimensionamento automático de aplicações com base na demanda:

• HPA (Horizontal Pod Autoscaler): O HPA é um recurso do Kubernetes que permite dimensionar automaticamente o número de réplicas de um Deployment com base na demanda de recursos. Ele monitora métricas, como utilização de CPU ou tráfego, e ajusta o número de réplicas para garantir que a aplicação tenha recursos suficientes para lidar com o tráfego.
• VPA (Vertical Pod Autoscaler): O VPA é um recurso que ajusta automaticamente os limites de recursos (CPU e memória) atribuídos a um Pod, com base na utilização real desses recursos. Isso permite otimizar o uso de recursos e garantir que a aplicação tenha recursos adequados para funcionar corretamente.

2. Configuração de políticas de recuperação automática:

• Probes: As Probes são usadas para verificar a disponibilidade de um aplicativo em um Pod. Existem dois tipos principais de Probes: Liveness Probe e Readiness Probe. A Liveness Probe verifica se o aplicativo está em execução corretamente, e a Readiness Probe verifica se o aplicativo está pronto para receber tráfego.
• Restart Policy: A política de reinicialização define o comportamento do Kubernetes quando um contêiner falha ou termina. É possível configurar a política de reinicialização para determinar se o Kubernetes deve reiniciar automaticamente os contêineres em caso de falha.
• Recursos de recuperação automática: O Kubernetes oferece recursos de recuperação automática, como Rolling Updates, que permitem atualizar ou fazer rollbacks de implantações de forma controlada e gradual. Isso garante que a aplicação permaneça disponível durante as atualizações e permite reverter para uma versão anterior em caso de problemas.

3. Estratégias para lidar com falhas em nós do cluster:

• Tolerância a falhas: O Kubernetes é projetado para lidar com falhas de nós do cluster de forma transparente. Ele pode redistribuir automaticamente as cargas de trabalho para outros nós saudáveis e garantir a disponibilidade contínua da aplicação.
• Replicação e balanceamento de carga: Ao implantar uma aplicação no Kubernetes, é possível configurar várias réplicas de Pods para distribuir a carga entre os nós do cluster. Isso garante que, se um nó falhar, outros nós possam assumir a carga de trabalho e manter a aplicação em execução.
• Armazenamento persistente: Utilize volumes persistentes para armazenar dados de forma persistente. Ao usar volumes persistentes, os dados não são perdidos quando um nó falha ou é reiniciado.

Ao implementar essas práticas de escalabilidade e tolerância a falhas, você estará construindo uma infraestrutura resiliente que pode se adaptar à demanda e lidar com falhas de forma eficiente. É importante considerar as necessidades específicas de sua aplicação e ajustar as configurações de acordo.

Observabilidade e Monitoramento:

A observabilidade e o monitoramento são fundamentais para garantir o bom funcionamento do seu cluster Kubernetes.

1. Ferramentas e práticas para monitorar e observar clusters Kubernetes:

• Kubernetes Dashboard: O Kubernetes Dashboard é uma interface web que permite visualizar informações detalhadas sobre o cluster, como o estado dos nós, dos Pods e dos serviços. Ele fornece uma visão geral dos recursos e permite fazer inspeções mais detalhadas.
• kubectl: A ferramenta de linha de comando kubectl oferece vários comandos para monitorar e inspecionar o cluster Kubernetes. Você pode usar comandos como kubectl get, kubectl describe e kubectl logs para obter informações sobre os recursos e visualizar logs dos contêineres em execução.
• APIs do Kubernetes: O Kubernetes expõe APIs que permitem acessar e monitorar o estado do cluster e dos recursos. Você pode utilizar essas APIs para obter informações detalhadas e criar suas próprias ferramentas de monitoramento personalizadas.

2. Registro de eventos, métricas e análise de logs:

• Eventos do Kubernetes: O Kubernetes registra eventos para informar sobre ações e mudanças ocorridas no cluster. Os eventos fornecem informações úteis para entender o comportamento e o estado do cluster, ajudando a identificar problemas e tomar ações corretivas.
• Métricas do Kubernetes: O Kubernetes expõe várias métricas que podem ser coletadas e monitoradas para obter insights sobre o desempenho do cluster, dos nós e das aplicações. Essas métricas incluem utilização de CPU, memória, tráfego de rede e muito mais.
• Análise de logs: É importante coletar e analisar os logs dos contêineres em execução no cluster Kubernetes. Os logs podem conter informações valiosas para identificar problemas, depurar aplicações e entender o comportamento do sistema. Ferramentas como o Elasticsearch, Fluentd e Kibana (EFK) ou o Elasticsearch, Logstash e Kibana (ELK) são comumente utilizadas para coletar e visualizar logs.

3. Utilização de soluções externas, como Prometheus e Grafana:

• Prometheus: O Prometheus é uma popular solução de monitoramento e coleta de métricas que pode ser integrada ao Kubernetes. Ele coleta métricas de diferentes componentes do cluster e permite consultas flexíveis e alertas com base nessas métricas.
• Grafana: O Grafana é uma plataforma de visualização e monitoramento que pode ser utilizada em conjunto com o Prometheus para criar painéis e gráficos personalizados. Ele permite a criação de dashboards visualmente atraentes e oferece recursos avançados de consulta e análise de métricas.

Integrar essas ferramentas e práticas de observabilidade e monitoramento ao seu cluster Kubernetes ajudará a identificar problemas, otimizar o desempenho e garantir uma operação confiável do sistema. Lembre-se de configurar alertas para ser notificado sobre eventos importantes e estar sempre atento às métricas relevantes para a saúde do seu cluster e das aplicações em execução.

Avançado: Recursos e Técnicas Avançadas:

Para aproveitar ao máximo o Kubernetes, é importante explorar recursos avançados e técnicas que permitem maior flexibilidade e integração com outros sistemas. Aqui estão alguns tópicos relacionados a esse tema:

1. Exploração de recursos avançados do Kubernetes:

• StatefulSets: Os StatefulSets são usados para lidar com aplicações que exigem identificadores únicos e armazenamento persistente, como bancos de dados. Eles garantem que cada Pod tenha um estado único e estável, permitindo a escala e a atualização dessas aplicações de forma segura.
• DaemonSets: Os DaemonSets permitem executar um Pod em cada nó do cluster. Isso é útil para tarefas que precisam ser executadas em todos os nós, como coleta de métricas ou configuração de serviços de monitoramento.
• Jobs: Os Jobs são usados para executar tarefas em lotes, que são executadas uma única vez até a conclusão. Isso é útil para trabalhos pontuais, como processamento de dados em massa ou migrações de bancos de dados.

2. Integração com sistemas externos:

• Bancos de dados: É possível integrar o Kubernetes com bancos de dados externos, como MySQL, PostgreSQL ou MongoDB. Isso envolve a criação de serviços e a configuração correta das conexões com os bancos de dados dentro dos Pods.
• Sistemas de mensageria: O Kubernetes pode ser integrado a sistemas de mensageria, como RabbitMQ ou Apache Kafka, para criar arquiteturas de microsserviços assíncronas e escaláveis. É possível utilizar bibliotecas ou adaptadores específicos para se conectar aos sistemas de mensageria.

3. Uso de recursos personalizados e extensões do Kubernetes:

• Custom Resource Definitions (CRDs): Os CRDs permitem a criação de recursos personalizados no Kubernetes. Isso permite estender a funcionalidade do Kubernetes e definir recursos específicos do domínio da sua aplicação.
• Operators: Os Operators são controladores personalizados que automatizam a operação e o gerenciamento de aplicativos complexos no Kubernetes. Eles utilizam CRDs para definir e gerenciar recursos específicos de um aplicativo, simplificando as operações diárias.
• Extensões do Kubernetes: Além dos recursos nativos, o Kubernetes possui várias extensões e integrações disponíveis na forma de plugins e addons. Essas extensões podem adicionar recursos adicionais, como autenticação, autorização, monitoramento avançado ou gerenciamento de rede.

Explorar esses recursos e técnicas avançadas do Kubernetes permitirá que você crie arquiteturas mais complexas, integre-se com sistemas externos e estenda a funcionalidade do Kubernetes para atender às necessidades específicas da sua aplicação. É importante lembrar de considerar as melhores práticas, manter a segurança e garantir a estabilidade e confiabilidade do seu cluster.

E por fim… Neste artigo, exploramos os fundamentos do Kubernetes, desde sua definição e conceitos básicos até a comparação com outras soluções de orquestração de contêineres.

O Kubernetes se tornou a escolha preferida para orquestração de contêineres devido à sua flexibilidade, escalabilidade e recursos avançados. Ao seguir as etapas abordadas neste artigo, você estará preparado para dar seus primeiros passos com o Kubernetes e começar a aproveitar seus benefícios.

É importante ressaltar a importância de continuar aprendendo e explorando os recursos e práticas recomendadas do Kubernetes à medida que você ganha mais experiência. A comunidade do Kubernetes está sempre em constante evolução, com atualizações e novos recursos sendo lançados regularmente. Portanto, manter-se atualizado e participar de eventos e comunidades relacionadas ao Kubernetes é fundamental para aprimorar suas habilidades e se manter atualizado com as melhores práticas.

Lembre-se de que, embora o Kubernetes possa ser desafiador no início, com dedicação, prática e o uso adequado dos recursos disponíveis, você estará bem encaminhado para dominar essa poderosa plataforma de orquestração de contêineres.

Agora que você está familiarizado com os conceitos e práticas iniciais do Kubernetes, sinta-se à vontade para explorar ainda mais, experimentar e aplicar o Kubernetes em seus projetos. Não tenha medo de explorar além do básico e buscar soluções personalizadas que se adaptem às suas necessidades específicas.

Esperamos que este artigo tenha sido útil para você começar sua jornada com o Kubernetes. Aproveite o poder do Kubernetes para orquestrar suas aplicações em contêineres de forma eficiente, escalável e confiável. Boa sorte em suas explorações com o Kubernetes!

Sobre o autor: Edwildson Coelho Rodrigues — É desenvolvedor na Sysvale Softgroup e formando no curso de Engenharia da Computação.

Iniciando com Kubernetes — Parte 2/2 was originally published in sysvale on Medium, where people are continuing the conversation by highlighting and responding to this story.

Salve guys!

Eu me chamo Edwildson e sou desenvolvedor na Sysvale. Estão prontos para embarcar na jornada fascinante do Kubernetes? Se você está começando agora e deseja entender o que exatamente é essa tal de orquestração de contêineres, você está no lugar certo! Neste guia, vamos simplificar o Kubernetes para você que está dando os primeiros passos nesse mundo empolgante.

O Kubernetes é como um super-herói dos contêineres. Ele ajuda no gerenciamento de aplicativos e serviços que rodam dentro desses contêineres. Mas o que são contêineres? São como pacotes autossuficientes que abraçam tudo que seu aplicativo precisa para funcionar: código, bibliotecas, dependências e até configurações. E a orquestração é a prática de gerenciar um grupo de contêineres de forma eficiente.

O Kubernetes veio para simplificar a vida dos desenvolvedores. Com ele, você pode se concentrar em criar seus aplicativos incríveis sem se preocupar tanto com a infraestrutura por trás. Ele possui recursos poderosos, como dimensionamento automático, recuperação automática de falhas e distribuição de carga. Tudo isso para manter seus aplicativos em execução de maneira confiável, mesmo em situações desafiadoras.

Neste artigo, vamos abordar os conceitos fundamentais do Kubernetes, bem facinho. Vamos mostrar como configurar seu ambiente, criar um cluster do Kubernetes e implantar seus aplicativos. Vamos também explorar as principais ferramentas do Kubernetes, como Pods, Services e Deployments.

Fundamentos do Kubernetes:

O Kubernetes é uma plataforma de código aberto que permite a orquestração de contêineres. Mas o que isso realmente significa? Vamos desvendar!

— Contêineres: Comecemos com o conceito de contêineres. Eles são como pacotes que contêm todos os componentes necessários para executar um aplicativo, incluindo código, bibliotecas e dependências. Os contêineres são leves, portáteis e isolados uns dos outros, o que facilita a implantação consistente de aplicativos em diferentes ambientes.

— Orquestração: Agora, imagine que você tem vários contêineres de diferentes aplicativos que precisam ser implantados, gerenciados e escalados. Aqui é onde entra a orquestração. O Kubernetes permite coordenar e automatizar todas essas tarefas complexas para que seus contêineres funcionem em harmonia.

— Unidades básicas do Kubernetes:

• Pod: É a unidade fundamental no Kubernetes. Um pod é um grupo de um ou mais contêineres que compartilham o mesmo ambiente de execução, como endereço IP e espaço de armazenamento. Os contêineres em um pod são geralmente co-localizados e se comunicam entre si.
• Node (nó): É uma máquina (física ou virtual) que executa o Kubernetes. Cada nó é responsável por executar os contêineres e outros componentes do Kubernetes.
• Cluster: É um conjunto de nós (nodes) que trabalham juntos para executar aplicativos. O Kubernetes gerencia e distribui as tarefas de forma inteligente entre os nós do cluster para garantir que tudo funcione de maneira eficiente e resiliente.
• Serviço (Service): É um recurso abstrato que define um conjunto lógico de pods e uma política de acesso a esses pods. Um serviço permite que os pods sejam descobertos e acessados de forma confiável, independentemente de sua localização no cluster.

Esses são apenas alguns dos conceitos básicos do Kubernetes. À medida que você se aprofunda, descobrirá mais recursos e conceitos poderosos que o Kubernetes oferece.

Configuração do Ambiente:

Antes de começar a utilizar o Kubernetes, é importante configurar o ambiente de maneira adequada.

1. Opções de instalação do Kubernetes em diferentes plataformas:

• Instalação local: Você pode instalar o Kubernetes em seu ambiente de desenvolvimento local usando ferramentas como Minikube ou Kind. Isso permite que você experimente o Kubernetes em uma configuração de cluster de um único nó.
• Nuvem pública: As principais provedoras de nuvem pública, como Amazon Web Services (AWS), Google Cloud Platform (GCP) e Microsoft Azure, oferecem serviços gerenciados de Kubernetes, como o Amazon Elastic Kubernetes Service (EKS), Google Kubernetes Engine (GKE) e Azure Kubernetes Service (AKS). Essas opções simplificam a configuração e o gerenciamento do cluster Kubernetes em uma infraestrutura em nuvem.
• Nuvem privada: Se você possui uma infraestrutura própria, é possível implantar o Kubernetes em um ambiente de nuvem privada usando ferramentas como o Rancher ou OpenShift. Essas soluções permitem a criação e o gerenciamento de clusters Kubernetes em sua própria infraestrutura.

2. Requisitos de hardware e software:

• Hardware: Os requisitos de hardware podem variar dependendo do tamanho do cluster e dos recursos necessários para suas cargas de trabalho. Em geral, você precisará de nós (nodes) com recursos como CPU, memória e armazenamento suficientes para executar os contêineres e os serviços do Kubernetes de maneira eficiente. Além disso, é recomendável ter uma rede com boa conectividade entre os nós do cluster.
• Software: O Kubernetes pode ser executado em diferentes sistemas operacionais, incluindo Linux, Windows e macOS. Você precisará de uma versão compatível do sistema operacional, além de ferramentas como o Docker para executar os contêineres. É importante garantir que as versões do Kubernetes, Docker e outras dependências estejam em conformidade com os requisitos da versão que você está instalando.

3. Ferramentas úteis para o gerenciamento do Kubernetes:

• Kubectl: É uma ferramenta de linha de comando utilizada para interagir com o cluster Kubernetes. Ela permite criar, modificar e gerenciar recursos no cluster, além de fornecer informações sobre o estado do cluster e dos pods.
• Dashboard: O Kubernetes Dashboard é uma interface gráfica que fornece uma visão geral do cluster e permite visualizar e gerenciar os recursos do Kubernetes de forma intuitiva. É uma opção conveniente para aqueles que preferem uma abordagem mais visual.
• Helm: É um gerenciador de pacotes para o Kubernetes que simplifica a implantação e o gerenciamento de aplicativos. Com o Helm, você pode instalar, atualizar e desinstalar aplicativos em seu cluster Kubernetes de forma simples e padronizada.
• Monitoramento e logs: Existem várias ferramentas de monitoramento e logs disponíveis para o Kubernetes, como o Prometheus e o Grafana. Essas ferramentas permitem monitorar a saúde do cluster, coletar métricas e analisar registros para solução de problemas e otimização de desempenho.

Lembre-se de consultar a documentação oficial do Kubernetes e das ferramentas específicas para obter instruções detalhadas sobre como configurar o ambiente de acordo com sua plataforma e requisitos específicos.

Criação do Primeiro Cluster:

Segue um passo a passo simplificado para criar um cluster Kubernetes básico usando a ferramenta Minikube:

1. Instalação do Minikube e das dependências:

• Verifique se você tem o hypervisor adequado instalado em sua máquina, como o VirtualBox ou o KVM, dependendo do seu sistema operacional.
• Faça o download e instale o Minikube de acordo com as instruções específicas do seu sistema operacional.

2. Inicialização do cluster com Minikube:

• Abra um terminal ou prompt de comando e execute o seguinte comando: minikube start. Isso irá inicializar o cluster Kubernetes local usando o Minikube.
• Aguarde enquanto o Minikube configura o cluster. Isso pode levar alguns minutos.

3. Verificação do cluster:

• Após a inicialização bem-sucedida, execute o comando kubectl cluster-info para verificar o estado do cluster e obter informações sobre o servidor API do Kubernetes.
• Execute o comando kubectl get nodes para verificar se o nó do cluster está em execução e pronto para receber cargas de trabalho.

4. Implantação de um aplicativo de exemplo:

• Você pode implantar um aplicativo de exemplo para testar o cluster. Por exemplo, execute o comando kubectl create deployment hello-minikube --image=k8s.gcr.io/echoserver:1.4 para implantar um aplicativo "echoserver" simples no cluster.
• Em seguida, execute o comando kubectl expose deployment hello-minikube --type=NodePort --port=8080 para expor o aplicativo como um serviço no cluster.

5. Acesso ao aplicativo:

• Para acessar o aplicativo, execute o comando minikube service hello-minikube para abrir o aplicativo no navegador padrão.
• Você verá uma página exibindo uma resposta do aplicativo “echoserver”, confirmando que o aplicativo foi implantado com sucesso.

Esse é um exemplo simplificado de criação de um cluster Kubernetes usando o Minikube.

Implantação e Gerenciamento de Aplicações:

Implantar e gerenciar aplicações no Kubernetes é uma das principais vantagens dessa plataforma.

1. Criação de imagens de contêineres adequadas para o Kubernetes:

• Escolha uma base adequada: Comece selecionando uma imagem base adequada para o seu aplicativo. Existem várias opções disponíveis, como imagens oficiais do Docker Hub ou imagens personalizadas baseadas em suas necessidades específicas.
• Dockerfile: Utilize um arquivo Dockerfile para definir as etapas necessárias para criar a imagem do contêiner. O Dockerfile contém as instruções para instalar dependências, configurar o ambiente e copiar os arquivos do aplicativo para o contêiner.
• Build da imagem: Utilize o comando docker build para construir a imagem do contêiner com base no Dockerfile. Certifique-se de especificar um nome e uma tag adequados para a imagem.
• Registro de imagens: Envie a imagem criada para um registro de imagens, como o Docker Hub ou um registro privado, para que ela possa ser acessada pelos nós do cluster Kubernetes durante a implantação.

2. Implantação de uma aplicação em um cluster Kubernetes:

• Manifesto de implantação: Crie um manifesto de implantação em formato YAML ou JSON para definir como a aplicação deve ser implantada no cluster Kubernetes. O manifesto inclui detalhes como nome da implantação, imagem do contêiner, portas expostas, réplicas desejadas e outros recursos necessários.
• Aplicação do manifesto: Utilize o comando kubectl apply -f <nome-do-arquivo.yaml> para aplicar o manifesto de implantação ao cluster. Isso iniciará o processo de implantação da aplicação nos nós disponíveis.
• Verificação da implantação: Utilize o comando kubectl get deployments para verificar o status da implantação da aplicação. Você poderá ver o número de réplicas em execução, a disponibilidade e outros detalhes relevantes.

3. Escalonamento, atualização e rollbacks de aplicações:

• Escalonamento: Utilize comandos como kubectl scale para aumentar ou diminuir o número de réplicas de uma implantação. Isso permite ajustar a capacidade da aplicação de acordo com as demandas do tráfego.
• Atualização: Para atualizar a aplicação, faça alterações no manifesto de implantação, como a versão da imagem do contêiner. Em seguida, utilize o comando kubectl apply -f <nome-do-arquivo.yaml> novamente para aplicar as alterações ao cluster. O Kubernetes irá gerenciar a atualização de forma gradual e controlada, garantindo a disponibilidade contínua da aplicação.
• Rollbacks: Em caso de problemas com uma atualização, é possível realizar um rollback para uma versão anterior da aplicação. Utilize o comando kubectl rollout undo deployment <nome-da-implantação> para reverter para a versão anterior da implantação.

4. Monitoramento e logs das aplicações:

• Monitoramento: Utilize ferramentas de monitoramento, como Prometheus e Grafana, para coletar métricas e monitorar o desempenho da aplicação no cluster Kubernetes. Configure alertas para ser notificado em caso de problemas.

Para que este artigo não se torne cansado para se ler este foi dividido em 2 partes. Então nos vemos lá, até mais!

Sobre o autor: Edwildson Coelho Rodrigues — É desenvolvedor na Sysvale Softgroup e formando no curso de Engenharia da Computação.

Iniciando com Kubernetes was originally published in sysvale on Medium, where people are continuing the conversation by highlighting and responding to this story.