Com a facilidade de desenvolver software, muitas vezes, não nos preocupamos com a qualidade do software que estamos desenvolvendo. A qualidade do software é um fator muito importante para o sucesso de um projeto. É ela que garante que o software seja fácil de manter, fácil de evoluir e fácil de corrigir.

Muitas vezes focamos os nossos estudos e nosso tempo para o aprendizado de novas tecnologias e frameworks, mas esquecemos de estudar e aprender sobre arquitetura de software e isso é um grande erro. A arquitetura de software é o que garante a a manutenibilidade, a evolução e a correção do software.

Decidir qual arquitetura utilizar em um projeto é uma tarefa muito importante e que deve ser feita com muito cuidado. Uma escolha não muito acertada pode trazer muitos problemas para o projeto e para a equipe de desenvolvimento, e grande problema é que esses efeitos colaterais podem não ser percebidos no início do projeto, mas sim ao longo do tempo.

Alguns dos principais problemas que podem ser causados por uma arquitetura de software não muito acertada são grande acoplamento entre os módulos do software, baixa coesão entre os módulos, dificuldade em escalar, problemas de performance, dificuldade em testar entre outros.

Imagine o seguinte cenário: o tempo foi passando, você e sua equipe foram notando que o software está ficando cada vez mais complexo, parece que a cada nova funcionalidade que é implementada, o software fica mais instável, mais difícil de manter, mais difícil de evoluir e mais difícil de corrigir. E agora? O que fazer?

Eis que surge do nada a palavra mágica: Microservices. Microservices é a solução para todos os problemas de arquitetura de software. Microservices é a solução para todos os problemas de acoplamento, coesão, escalabilidade, performance e testes.

Eu concordo que micro-serviços são uma excelente solução para muitos problemas de arquitetura de software, mas não são a solução para todos os problemas.

Você já pensou em refatorar seu código antes de tentar uma solução mais complexa como micro-serviços?

Pensou em estudar e aprender sobre arquitetura de software antes de tentar uma solução baseada puramente em tendências do momento ou em soluções que funcionaram para outras empresas?

A Netflix, Amazon, Google tem soluções ótimas para os problemas de arquitetura de software dela, mas será que essas soluções funcionam para o seu projeto?

Será que está na hora de você e sua equipe pararem de tentar soluções mágicas e começarem a estudar e aprender sobre qualidade e arquitetura de software?

Você não acha que usar micro-serviços para resolver problemas de arquitetura de software é um débito técnico?

Não vou dar resposta para essas perguntas, mas acho que você deveria pensar sobre isso.

Não acho que você nunca deve usar micro-serviços, mas acho que você deve pensar muito antes de usar.

Existem sim casos onde essa arquitetura faz todo sentido, mas existe uma grande quantidade de casos onde essa arquitetura só esta sendo usada para resolver débitos técnicos deixados por uma decisão errada tomada no início do projeto.

Não abomine microservices, mas não os use como solução para todos os problemas.

Estude, aprenda, e tome decisões baseadas em fatos e não em tendências.

Manter um software de qualidade é um trabalho árduo e que exige muito estudo e dedicação, mas é um trabalho que vale a pena.

E você, o que acha? Microservices são débitos técnicos?

Quando começamos a desenvolver, monolitos são a nossa primeira experiência na maioria das vezes. Eles são fáceis de desenvolver, testar e implantar. No entanto, à medida que a aplicação cresce, o monolito começa a se tornar um problema.

A escalabilidade de um software é a uma das coisas mais importantes a serem consideradas hoje. Saber lidar de forma dinâmica com o crescimento de usuários e dados é essencial para o sucesso de um software.

Sistemas monolíticos são difíceis de escalar. Eles são construídos como um único bloco de código, o que significa que, para escalar a aplicação, você precisa replicar todo o código ou escalar verticalmente o servidor. Isso pode ser caro e ineficiente.

Escalabilidade vertical é a capacidade de aumentar a capacidade de um servidor, adicionando mais recursos, como CPU, RAM e disco. Isso é feito para melhorar o desempenho de um servidor.

Escalabilidade horizontal é a capacidade de aumentar a capacidade de um sistema, adicionando mais instâncias do sistema. Isso é feito para melhorar a disponibilidade e a confiabilidade de um sistema.

Microservices é uma arquitetura de software que resolve esse problema (mas cria outros). Em vez de construir uma única aplicação monolítica, você constrói várias aplicações pequenas e independentes, chamadas de micro-serviços. Cada microservice é responsável por uma parte específica da aplicação e se comunica com outras aplicações.

Embora, em teoria, os micro-serviços pareçam oferecer uma solução ideal para problemas de escalabilidade, eles apresentam desafios próprios na prática. Um dos principais desafios é o gerenciamento do acoplamento entre eles.

No mundo ideal, microservices devem ser independentes e desacoplados. Isso significa que uma aplicação deve ser capaz de funcionar sem depender de outra. No entanto, principalmente em migrações de sistemas monolíticos para microservices, é comum que dependam uns dos outros e chamamos isso de acoplamento.

Existem dois tipos de acoplamento em microservices: acoplamento estático e acoplamento dinâmico, e é sobre eles que vamos falar hoje.

Exemplo de arquitetura de microservices

Componentes:

1. API Gateway:

   • Atua como o ponto de entrada para todas as solicitações externas ao sistema.

   • Recebe requisições HTTP dos clientes e as encaminha para os serviços internos apropriados (como ProductCatalogService, OrderService, e UserService).

   • Manter o controle de acesso, autenticação, roteamento de requisições, e agregação de respostas.

2. ProductCatalogService:

   • Gerencia informações sobre produtos à venda, como descrições, preços e disponibilidade.

   • Pode consultar um serviço de descoberta como o Consul para localizar outros serviços necessários.

3. OrderService:

   • Gera pedidos de compra.

   • Interage com outros serviços para obter informações do produto (via ProductCatalogService) e detalhes do usuário (via UserService).

   • Manipula pedidos no banco de dados MongoDB e publica eventos de pedidos para o RabbitMQ, permitindo comunicação assíncrona com outros serviços.

4. UserService:

   • Administra informações de usuários, como perfis, preferências e histórico de compras.

   • Permite que outros serviços venham a consultar informações do usuário de forma segura.

5. PaymentService:

   • Responsável pelo processamento de transações de pagamento.

   • Interage com o banco de dados MongoDB para armazenar informações sobre transações financeiras.

   • Publica eventos de transação no RabbitMQ para permitir que outros serviços (como o NotificationService) sejam notificados sobre ocorrências financeiras.

6. RabbitMQ:

   • Permite a mensageria assíncrona entre serviços, facilitando a comunicação desacoplada.

   • Transmite eventos de pedidos e transações para partes interessadas.

7. NotificationService:

   • Envia notificações para os usuários com base em eventos recebidos através do RabbitMQ, como atualizações de status de pedidos ou mensagens de confirmação de pagamento.

8. MongoDB:

   • Armazena dados críticos para o sistema, como informações de pedidos, usuários e transações.

   • Um banco de dados NoSQL, como o MongoDB, é bem adequado para sistemas que exigem flexibilidade de esquema e manuseio eficiente de dados não estruturados.

9. Consul:

   • Serviço utilizado para descoberta, configuração e gerenciamento de serviços.

   • Permite que microservices descubram dinamicamente a localização de outros serviços, facilitando uma arquitetura altamente flexível e resiliente.

10. Nginx:

    • Pode representar um servidor web reverso ou balançador de carga que distribui requisições entre várias instâncias do API Gateway, melhorando a capacidade e a disponibilidade.

Acoplamento estático

Os componentes em verde representam acoplamento estático.

O acoplamento estático ocorre quando um microservice depende de outro microservice em tempo de compilação ou configuração inicial do sistema.

Na maioria das vezes, acoplamentos estáticos são fáceis de identificar. Os mais comuns são:

1. Dependência de código: um microservice chama diretamente outro através de uma chamada de função ou API.

2. Dependência de banco de dados: um microservice acessa diretamente o banco de dados de outra aplicação.

3. Dependência de configuração: um micro-serviço depende de configurações específicas de outro microservice.

Outra forma de acoplamento estático é quando um microservice depende de um contrato específico de outro. Por exemplo, um microservice espera que outro serviço retorne um objeto JSON específico. Se o contrato mudar, o microservice que depende dele pode quebrar, então é preciso atualizar a aplicação que depende do contrato.

Acoplamento dinâmico

Os componentes em azul representam acoplamento dinâmico.

O acoplamento dinâmico ocorre quando um microservice depende de outro em tempo de execução.

Na maioria das vezes, acoplamentos dinâmicos são mais difíceis de identificar. Os mais comuns são:

1. Dependência de mensageria: um microservice envia uma mensagem para um barramento de mensagens e espera que outro serviço responda.

2. Dependência de descoberta de serviço: um microservice consulta um serviço de descoberta para localizar outro.

O interessante do acoplamento dinâmico é que ele permite que microservices sejam mais independentes e desacoplados. Se um microservice não estiver disponível, o que depende dele pode continuar funcionando, mesmo que de forma limitada.

Conclusão

Na hora de projetar microservices, é importante considerar o acoplamento entre eles. Acoplamento estático e acoplamento dinâmico são duas formas de acoplamento que podem ser usadas em sistemas distribuídos.

Não existe uma regra rígida sobre qual tipo de acoplamento é melhor. Na verdade, a maioria dos sistemas de microservices terá uma combinação de acoplamento estático e acoplamento dinâmico.

Você como arquiteto precisa decidir qual tipo de acoplamento faz mais sentido para o problema que você está resolvendo no momento. Em alguns casos, acoplamento estático pode ser mais simples e eficiente. Em outros casos, acoplamento dinâmico pode ser mais flexível e resiliente.

O importante é entender as diferenças entre acoplamento estático e acoplamento dinâmico e saber quando usar cada um deles.

Referências

• Arquitetura de Software: as Partes Difíceis: Análises Modernas de Trade-off Para Arquiteturas Distribuídas

Neste artigo vamos falar sobre a Arquitetura Orientada a Eventos (Event-driven Architecture — EDA), uma arquitetura que tem como principal característica a comunicação entre os serviços através de eventos.

O que é EDA?

A Arquitetura Orientada a Eventos (Event-driven Architecture — EDA) é um estilo de arquitetura de software que promove a produção, detecção, consumo e reação a eventos. Um evento pode ser qualquer coisa que seja notável ou significativa para o sistema, como alterações de estado, uma ação do usuário, um erro, uma mensagem recebida, entre outros.

Os eventos são mensagens assíncronas que são geradas por um produtor e consumidas por um ou mais consumidores. O produtor não precisa saber quem são os consumidores, e os consumidores não precisam saber quem são os produtores. Isso permite que os sistemas sejam desacoplados, escaláveis e flexíveis.

No nosso exemplo de hoje vamos simular o seguinte cenário:

Exemplo prático

O sistema é composto por 4 serviços:

ecommerce-frontend:

• Frontend de um e-commerce que permite ao usuário adicionar produtos ao carrinho.
• Usa React para criar a interface do usuário.

stock-service:

• Serviço que gerencia o estoque dos produtos.
• Usa PHP para comuncição com o RabbitMQ.

<?php
require __DIR__ . '/vendor/autoload.php';

use PhpAmqpLib\Connection\AMQPStreamConnection;
use PhpAmqpLib\Message\AMQPMessage;

header("Access-Control-Allow-Origin: *");
header("Access-Control-Allow-Headers: *");
header("Access-Control-Allow-Methods: *");

if ($_SERVER['REQUEST_METHOD'] === 'POST') {

$order = json_decode(file_get_contents('php://input'), true);

$success = true;

$connection = new AMQPStreamConnection('rabbitmq', 5672, 'guest', 'guest');
$channel = $connection->channel();

$channel->queue_declare('stock_updated', false, false, false, false);

$msg = new AMQPMessage(json_encode([
'order_id' => 1,
'status' => 'updated'
]));

$channel->basic_publish($msg, '', 'stock_updated');

$channel->close();
$connection->close();

header('Content-Type: application/json');
echo json_encode(['success' => $success]);
}

O código acima é somente um exemplo didático, não é um código funcional e nem seguro.

payment-service:

• Serviço que os pagamentos dos pedidos.
• Usa Python para comunicação com o RabbitMQ.

import pika
import json
import time

max_retries = 5
retry_delay = 5

def establish_connection(max_retries, retry_delay):
for i in range(max_retries):
try:
connection = pika.BlockingConnection(pika.ConnectionParameters('rabbitmq'))
return connection
except pika.exceptions.AMQPConnectionError:
if i < max_retries - 1:
time.sleep(retry_delay)
else:
raise

def process_payment(order):
print(f"Processando pagamento para o pedido: {order['order_id']}")
return True

def callback(ch, method, properties, body):
order = json.loads(body)
success = process_payment(order)

payment_event = json.dumps({
'order_id': order['order_id'],
'status': 'processed' if success else 'failed'
})

try:
channel.basic_publish(exchange='', routing_key='payment_processed', body=payment_event)
print(f"Pagamento {'sucesso' if success else 'falha'} para o pedido: {order['order_id']}")
except pika.exceptions.AMQPError as e:
print(f"Erro ao publicar mensagem: {str(e)}")

def setup_channel(connection):
channel = connection.channel()
channel.queue_declare(queue='stock_updated')
channel.queue_declare(queue='payment_processed')
channel.basic_consume(queue='stock_updated', on_message_callback=callback, auto_ack=True)
return channel

if __name__ == "__main__":
connection = establish_connection(max_retries, retry_delay)
channel = setup_channel(connection)
print('Aguardando eventos de atualização de estoque...')
try:
channel.start_consuming()
except KeyboardInterrupt:
print('Interrompido pelo usuário')
finally:
if connection:
connection.close()

O código acima é somente um exemplo didático, não é um código funcional e nem seguro.

rabbitmq:

• Servidor de mensageria que permite a comunicação entre os serviços.

O link para o repositório com o código completo está disponível aqui.

Fluxo de comunicação

1. O usuário acessa o frontend do e-commerce e adiciona um produto ao carrinho.
2. O frontend envia uma requisição para o serviço de estoque para realizar o checkout do produto.
3. O serviço de estoque verifica se o produto está disponível e envia um evento de atualização de estoque para o RabbitMQ.
4. O serviço de pagamento consome o evento de atualização de estoque e processa o pagamento do pedido.
5. O serviço de pagamento envia um evento de pagamento processado para o RabbitMQ.

Trade-offs

Esse fluxo de comunicação é um exemplo simples de como a Arquitetura Orientada a Eventos (EDA) pode ser utilizada para desacoplar os serviços e permitir que eles se comuniquem de forma assíncrona e sem a necessidade de saber quem são os produtores ou consumidores dos eventos, tanto que foi por isso que resolvi usar diferentes linguagens de programação para cada serviço.

Tudo isso permite que os serviços sejam escaláveis, flexíveis e resilientes, pois cada serviço é responsável por uma única tarefa e pode ser facilmente substituído ou atualizado sem afetar os outros serviços.

Mas nem tudo são flores, a Arquitetura Orientada a Eventos (EDA) também tem suas desvantagens, como a complexidade de implementação, a necessidade de garantir a ordem dos eventos, a dificuldade de depurar problemas e a necessidade de garantir a entrega dos eventos.

Por isso, é importante avaliar se a Arquitetura Orientada a Eventos (EDA) é a melhor escolha para o seu projeto e se você está disposto a lidar com as suas complexidades.

Conclusão

Essa foi somente uma introdução à Arquitetura Orientada a Eventos (EDA), uma arquitetura que tem como principal característica o desacoplamento dos serviços através de eventos assíncronos.

Não existe uma arquitetura perfeita, cada uma tem suas vantagens e desvantagens, e cabe a você escolher a que melhor se adequa ao seu projeto e às suas necessidades.

Espero que esse artigo tenha te ajudado a entender um pouco mais sobre a Arquitetura Orientada a Eventos (EDA) e como ela pode ser utilizada para criar sistemas escaláveis, flexíveis e resilientes.

O link para o repositório com o código completo está disponível aqui.

Se você tiver alguma dúvida ou sugestão, deixe nos comentários abaixo.

Mas antes de falar sobre o algoritmo de Dijkstra, vamos falar sobre o algoritmo de Pesquisa em Largura.

Pesquisa em Largura

Trabalhar com grafos é uma tarefa comum em computação. Um dos problemas mais comuns é encontrar o menor caminho entre dois vértices em um grafo. O algoritmo de Pesquisa em Largura mostra como encontrar o menor caminho em um grafo, como por exemplo, o caminho mais curto entre duas cidades em um mapa que tem cidades como vértices e estradas como arestas.

Imagine que precisamos sair de A para chegar em G. O algoritmo de Pesquisa em Largura nos ajuda a encontrar o menor caminho. O algoritmo começa visitando o vértice de origem (A) e então explora todos os vértices vizinhos. Depois disso, explora os vértices que estão a dois passos de distância e assim por diante.

No nosso caso o menor caminho é A -> B -> E -> G.

Nesse caso, temos somente 3 passos para chegar em G.

Algoritmo de Dijkstra

Mas e se as arestas tiverem pesos? O algoritmo de Pesquisa em Largura não funciona mais. O algoritmo de Dijkstra é um algoritmo que encontra o caminho mais barato em um grafo direcionado ou não direcionado, com arestas que possuem pesos. O algoritmo de Dijkstra mantém duas listas: uma lista de vértices visitados e uma lista de vértices não visitados. Ele seleciona o vértice não visitado mais próximo do vértice de origem, marca-o como visitado e atualiza os pesos dos vértices vizinhos.

Vamos adaptar o exemplo anterior para incluir pesos nas arestas.

Agora temos pesos em cada aresta, e nosso desafio é encontrar o caminho em que a soma dos pesos seja menor.

Vamos aplicar o algoritmo de Dijkstra para encontrar o menor caminho de A para G.

1. Começamos em A e visitamos todos os vértices vizinhos.

2. O próximo vértice mais próximo de A é C. Então visitamos C e atualizamos as distâncias dos vértices vizinhos.

3. O próximo vértice mais próximo de A é D. Então visitamos D e atualizamos as distâncias dos vértices vizinhos.

4. O próximo vértice mais próximo de A é E. Então visitamos E e atualizamos as distâncias dos vértices vizinhos.

O menor caminho de A para G é A -> C -> D -> E -> G.

Aplicando isso com PHP

Vamos criar um exemplo prático em PHP para aplicar o algoritmo de Dijkstra.

<?php
$graph = [
    'A' => ['B' => 10, 'C' => 5],
    'B' => ['E' => 8, 'D' => 3],
    'C' => ['D' => 2, 'F' => 4],
    'D' => ['E' => 2, 'F' => 6],
    'E' => ['G' => 2],
    'F' => ['E' => 1],
    'G' => []
];

function dijkstra($graph, $source, $target)
{
    $dist = [];
    $prev = [];
    $queue = new SplPriorityQueue();

    foreach ($graph as $vertex => $adj) {
        $dist[$vertex] = INF;
        $prev[$vertex] = null;
        $queue->insert($vertex, $vertex === $source ? 0 : INF);
    }

    $dist[$source] = 0;

    while (!$queue->isEmpty()) {
        $u = $queue->extract();

        if (!empty($graph[$u])) {
            foreach ($graph[$u] as $v => $cost) {
                $alt = $dist[$u] + $cost;
                if ($alt < $dist[$v]) {
                    $dist[$v] = $alt;
                    $prev[$v] = $u;
                    $queue->insert($v, $alt);
                }
            }
        }
    }

    $path = [];
    $u = $target;
    while (isset($prev[$u])) {
        array_unshift($path, $u);
        $u = $prev[$u];
    }
    array_unshift($path, $source);

    return $path;
}

$path = dijkstra($graph, 'A', 'G');
echo implode(' -> ', $path);

Segue o passo a passo da execução do algoritmo:

• 1. Inicializamos as distâncias e a fila de prioridade.

• 2. Inicializamos a distância do vértice de origem como 0.

• 3. Enquanto a fila de prioridade não estiver vazia, extraímos o vértice com a menor distância.

• 4. Para cada vértice vizinho, calculamos a distância alternativa e atualizamos a distância se for menor.

• 5. Construímos o caminho percorrendo os vértices anteriores. 6. Retornamos o caminho.

  Conclusão

  Com o aumento do uso de AI, Machine Learning e Big Data, o conceito de grafos se tornou cada vez mais importante. O algoritmo de Dijkstra é um dos algoritmos mais importantes para encontrar o menor caminho em um grafo. Espero que você tenha entendido como o algoritmo de Dijkstra funciona e como ele pode ser aplicado em um cenário do mundo real. Se você gostou desse artigo, deixe um comentário e compartilhe com seus amigos. Até a próxima!

Neste artigo, vamos criar uma aplicação de microserviços com PHP, RabbitMQ e Docker. O RabbitMQ é um software de mensageria que implementa o protocolo AMQP (Advanced Message Queuing Protocol), que é um protocolo de mensagens assíncronas.

O que é RabbitMQ?

Vamos imaginar o seguinte cenário: você tem um sistema que precisa enviar e-mails para os usuários. Em vez de enviar os e-mails diretamente, você pode enviar uma mensagem para uma fila de mensagens, que será consumida por um serviço que envia os e-mails. Isso é o que o RabbitMQ faz: ele recebe mensagens de produtores e as envia para consumidores.

Dessa forma é possível desacoplar a produção de mensagens do consumo, o que permite escalar cada parte do sistema de forma independente. Além disso, o RabbitMQ garante que as mensagens sejam entregues na ordem correta e que não sejam perdidas.

Arquitetura da aplicação

Nossa aplicação será composta por dois microserviços: um produtor e um consumidor. O produtor será responsável por enviar mensagens para uma fila de mensagens, e o consumidor será responsável por consumir as mensagens e exibi-las no terminal.

Nosso primeiro passo será criar o arquivo docker-compose.yml para definir os serviços da nossa aplicação:

services:
  rabbitmq:
    image: "rabbitmq:3-management"
    container_name: "rabbitmq"
    ports:
      - "15672:15672"
      - "5672:5672"

  php-app:
    build: ./php-app
    depends_on:
      - rabbitmq

  node-app:
    build: ./node-app
    depends_on:
      - rabbitmq

Neste arquivo, definimos três serviços: rabbitmq, php-app e node-app. O serviço rabbitmq é baseado na imagem rabbitmq:3-management, que inclui a interface de gerenciamento do RabbitMQ. Os serviços php-app e node-app são baseados em imagens customizadas que iremos criar.

Criando o produtor com PHP

Agora, vamos criar o diretório php-app e o arquivo Dockerfile dentro dele:

mkdir php-app && touch php-app/Dockerfile

No arquivo Dockerfile, vamos definir a imagem base e copiar os arquivos da aplicação:

FROM php:7.4-cli

RUN apt-get update && apt-get install -y librabbitmq-dev libssl-dev git unzip wget curl

RUN docker-php-ext-install sockets pdo pdo_mysql
RUN pecl install amqp && docker-php-ext-enable amqp

COPY . /usr/src/myapp
WORKDIR /usr/src/myapp

RUN curl -sS https://getcomposer.org/installer | php -- --install-dir=/usr/local/bin --filename=composer

RUN composer clear-cache

RUN composer install

CMD ["php", "./publisher.php"]

Neste arquivo, definimos a imagem base php:7.4-cli e instalamos as dependências necessárias para o RabbitMQ e o Composer. Em seguida, copiamos os arquivos da aplicação para o diretório /usr/src/myapp, instalamos as dependências do Composer e executamos o script publisher.php.

Agora, vamos criar o arquivo publisher.php na raiz do projeto:

<?php
require_once __DIR__ . '/vendor/autoload.php';
use PhpAmqpLib\Connection\AMQPStreamConnection;
use PhpAmqpLib\Message\AMQPMessage;

$maxRetries = 5;
$retryDelay = 5;

for ($attempt = 0; $attempt < $maxRetries; $attempt++) {
    try {
        $connection = new AMQPStreamConnection('rabbitmq', 5672, 'guest', 'guest');
        $channel = $connection->channel();
        break;
    } catch (Exception $e) {
        echo "Failed to connect to RabbitMQ. Retrying in $retryDelay seconds...\n";
        sleep($retryDelay);
    }    
}

if (!isset($connection)) {
    echo "Not possible to connect to RabbitMQ. Exiting...\n The application will be restarted by Docker\n";
    exit(1);
}

$channel->queue_declare('hello', false, false, false, false);

$msg = new AMQPMessage('Hello, RabbitMQ! Now is ' . date('Y-m-d H:i:s'));
$channel->basic_publish($msg, '', 'hello');

echo " [x] Sent 'Hello, RabbitMQ!'\n";

$channel->close();
$connection->close();

Neste arquivo, criamos uma conexão com o RabbitMQ, declaramos uma fila chamada `hello` e enviamos uma mensagem para essa fila. Em seguida, fechamos a conexão com o RabbitMQ. Perceba que estamos tentando conectar ao RabbitMQ várias vezes, com um intervalo de 5 segundos entre as tentativas.

Isso é importante para garantir que a aplicação consiga se conectar ao RabbitMQ mesmo que ele não esteja disponível imediatamente. Isso é uma prática comum em aplicações distribuídas, onde a disponibilidade dos serviços pode variar ao longo do tempo, pesquise mais sobre `circuit breaker` e `retry pattern`.

Mas para instalar as dependências do RabbitMQ e do Composer, precisamos criar o arquivo `composer.json` na raiz do projeto:

{ "require": { "php-amqplib/php-amqplib": "^3.1", "phpseclib/phpseclib": "^3.0" } }

Criando o consumidor com Node.js

Agora, vamos criar o diretório `node-app` e o arquivo `Dockerfile` dentro dele:

mkdir node-app && touch node-app/Dockerfile

No arquivo `Dockerfile`, vamos definir a imagem base e copiar os arquivos da aplicação:

FROM node:14 
WORKDIR /usr/src/app 
COPY package\*.json ./ 
RUN npm install 
COPY . . 
CMD \["node", "subscriber.js"\]

Neste arquivo, definimos a imagem base `node:14`, copiamos os arquivos da aplicação para o diretório `/usr/src/app`, instalamos as dependências do Node.js e executamos o script `subscriber.js`.

Agora, vamos criar o arquivo `subscriber.js` na raiz do projeto:

const amqp = require('amqplib');

async function connectWithRetry() {
    const maxRetries = 5;
    const retryDelay = 5000;

    for (let attempt = 1; attempt <= maxRetries; attempt++) {
        try {
            const connection = await amqp.connect('amqp://rabbitmq');
            return connection;
        } catch (err) {
            console.error(`Not possible to connect to RabbitMQ. Retrying in ${retryDelay}ms. Attempt ${attempt} of ${maxRetries}`);
            await new Promise(resolve => setTimeout(resolve, retryDelay));
        }
    }

    throw new Error(`Failed to connect to RabbitMQ after ${maxRetries} attempts`);
}

async function receiveMessages() {
    try {
        const connection = await connectWithRetry();
        const channel = await connection.createChannel();
        const queue = 'hello';

        await channel.assertQueue(queue, { durable: false });

        console.log(" [*] Waiting for messages in %s.", queue);

        channel.consume(queue, function (msg) {
            console.log(" [x] Received: %s", msg.content.toString());
        }, {
            noAck: true
        });

    } catch (err) {
        console.error(err.message);
        process.exit(1);
    }
}

receiveMessages();

Neste arquivo, criamos uma conexão com o RabbitMQ, declaramos uma fila chamada `hello` e consumimos as mensagens dessa fila.

Em seguida, exibimos as mensagens no terminal. Assim como no produtor, estamos tentando conectar ao RabbitMQ várias vezes, com um intervalo de 5 segundos entre as tentativas. Isso é importante para garantir que o consumidor consiga se conectar ao RabbitMQ mesmo que ele não esteja disponível imediatamente.

E para instalar as dependências do RabbitMQ, precisamos criar o arquivo `package.json` na raiz do projeto:

{ "name": "node-app", "version": "1.0.0", "description": "", "main": "subscriber.js", "dependencies": { "amqplib": "^0.8.0" }, "author": "", "license": "ISC" }

Executando a aplicação

Agora que criamos os serviços do RabbitMQ, do produtor e do consumidor, vamos executar a aplicação com o Docker Compose:

docker compose up --build

Isso irá criar os containers dos serviços e executar a aplicação. Você verá as mensagens enviadas pelo produtor sendo exibidas no terminal pelo consumidor.

O RabbitMQ também estará disponível na porta 15672, onde você pode acessar a interface de gerenciamento e visualizar as filas e as mensagens.

Com isso, criamos uma aplicação de microserviços com PHP, RabbitMQ e Docker. Essa abordagem arquitetural permite escalar cada parte do sistema de forma independente e garante a entrega das mensagens na ordem correta.

Espero que este artigo tenha sido útil e que você possa aplicar esses conceitos em seus projetos. Se tiver alguma dúvida ou sugestão, deixe nos comentários.

Qualquer dúvida, estou à disposição.

Link do Repositório: Microservices e Mensageria com PHP, RabbitMQ e Docker

Streams são uma forma de abstrair a manipulação de dados de entrada e saída, permitindo que você leia e escreva dados de e para diferentes fontes, como arquivos, strings, conexões de rede, etc.

Por exemplo, você pode usar streams para ler dados de um arquivo, processá-los e escrevê-los em outro arquivo, sem ter que se preocupar com a origem ou destino dos dados.

Ou então, você pode usar streams para ler dados de uma conexão de rede, processá-los e escrevê-los em um banco de dados. E assim por diante.

Exemplo básico

$stream = fopen('data.txt', 'r');
while (!feof($stream)) {
$line = fgets($stream);
echo $line;
}
fclose($stream);

Neste exemplo, abrimos um arquivo chamado data.txt em modo de leitura ('r'). Em seguida, lemos o conteúdo do arquivo linha por linha até o final do arquivo (feof($stream)). Por fim, fechamos o arquivo com fclose($stream).

Mas o que é um stream? Um stream é um recurso que representa uma fonte ou destino de dados. No exemplo acima, $stream é um stream que representa o arquivo data.txt.

Vamos ver um exemplo mais avançado.

Exemplo avançado

$context = stream_context_create([
'http' => [
'method' => 'POST',
'header' => 'Content-Type: application/json',
'content' => json_encode(['key' => 'value']),
],
]);

$stream = fopen('http://example.com/data.csv', 'r', false, $context);
while (!feof($stream)) {
$line = fgetcsv($stream);
print_r($line);
}
fclose($stream);

Neste exemplo, criamos um contexto de stream com stream_context_create, que é um array associativo com opções de configuração para o stream. No caso, estamos configurando um stream HTTP com o método POST, o cabeçalho Content-Type: application/json e o corpo da requisição em formato JSON.

Em seguida, abrimos um stream para a URL http://example.com/data.csv em modo de leitura ('r') com o contexto de stream que acabamos de criar.

Depois, lemos o conteúdo do stream linha por linha com fgetcsv, que lê uma linha do stream e a converte em um array de valores separados por vírgula.

Por fim, fechamos o stream com fclose.

Mas por que usar streams?

O PHP surgiu em uma época em que a manipulação de arquivos era a principal forma de interagir com o sistema de arquivos e outros recursos de I/O. Por isso, as funções de manipulação de arquivos do PHP são baseadas em operações de baixo nível, como abrir, ler, escrever e fechar arquivos, os famosos fopen, fread, fwrite e fclose.

Com o tempo, a necessidade de interagir com outros tipos de recursos de I/O, como conexões de rede, bancos de dados, etc., tornou-se cada vez mais comum. E foi aí que os streams entraram em cena.

Streams são essencialmente uma camada de abstração sobre diferentes tipos de recursos de I/O, permitindo que você leia e escreva dados de e para esses recursos de forma consistente, independente da origem ou destino dos dados.

Quando eu falo de recursos de I/O, estou me referindo a qualquer coisa que você possa ler ou escrever dados, como arquivos, strings, janelas de console, conexões de rede, sockets, pipes, etc.

E quando eu falei de não se preocupar com a origem ou destino dos dados, eu quis dizer que você não precisa saber se está lendo de um arquivo, de uma conexão de rede, de um banco de dados, etc. Você simplesmente lê os dados do stream e os processa da forma que desejar. Isso é muito poderoso e flexível.

E como eu uso streams?

Para usar streams em PHP, você precisa entender alguns conceitos básicos:

• Resource
• Context
• Wrapper
• Stream functions
• Stream filters

Nota*: Este é apenas um resumo básico sobre streams em PHP. Para saber mais, consulte a [documentação oficial](https://www.php.net/manual/en/book.stream.php).*

Resource

Vamos nos aprofundar um pouco mais no conceito de recurso (resource) em PHP.

Um stream é representado por um recurso (resource) em PHP. Um recurso é uma variável especial que contém uma referência interna para um recurso externo, como um arquivo, uma conexão de rede, etc. Você pode criar um recurso com a função fopen e fechá-lo com a função fclose.

Um resource em PHP é indentificador interno para recursos externos, e a função get_resource_type pode ser usada para obter o tipo de recurso.

$stream = fopen('data.txt', 'r');
echo get_resource_type($stream);
fclose($stream);

No console, você verá algo como stream.

O resource sempre vai referenciar o arquivo aberto.

Context

Um contexto de stream é um array associativo com opções de configuração para o stream. Você pode criar um contexto de stream com a função stream_context_create e passá-lo como argumento para funções que abrem streams, como fopen, file_get_contents, etc.

Quando você abre um stream com um contexto de stream, as opções de configuração do contexto são aplicadas ao stream. Por exemplo, você pode configurar um stream HTTP com o método POST, o cabeçalho Content-Type: application/json, etc.

$context = stream_context_create([
'http' => [
'method' => 'POST',
'header' => 'Content-Type: application/json',
'content' => json_encode(['key' => 'value']),
],
]);

$stream = fopen('http://example.com/data.csv', 'r', false, $context);

Ou então, você pode usar um contexto de stream para configurar um stream FTP com o nome de usuário e senha.

$context = stream_context_create([
'ftp' => [
'username' => 'user',
'password' => 'pass',
],
]);

$stream = fopen('ftp://example.com/data.csv', 'r', false, $context);

Wrapper

Um wrapper é um esquema de URL que define como o PHP deve abrir um stream. Por exemplo, o wrapper http é usado para abrir streams HTTP, o wrapper ftp é usado para abrir streams FTP, etc.

Quando você abre um stream com fopen, o PHP usa o wrapper correspondente para abrir o stream. Por exemplo, se você abrir um stream http://example.com/data.csv, o PHP usará o wrapper http para abrir o stream.

Você também pode usar wrappers para abrir streams de outros tipos de recursos, como strings, variáveis de memória, etc.

$stream = fopen('data:text/plain;base64,SGVsbG8gV29ybGQ=', 'r');
echo stream_get_contents($stream);
fclose($stream);

Neste exemplo, estamos abrindo um stream de uma string codificada em base64 com o wrapper data. O conteúdo da string é Hello World.

$stream = fopen('php://memory', 'r+');

Neste exemplo, estamos abrindo um stream de uma variável de memória com o wrapper php. O stream é aberto em modo de leitura e escrita ('r+').

$stream = fopen('ogg://temp', 'r+');

OGG é um wrapper que permite a manipulação de arquivos de áudio no formato OGG, isso é um exemplo de um wrapper personalizado.

Você pode criar seus próprios wrappers personalizados para abrir streams de outros tipos de recursos, como bancos de dados, APIs, etc.

Veja a documentação oficial para mais informações sobre wrappers em PHP.

Stream functions

O PHP fornece várias funções para trabalhar com streams, como fopen, fclose, fread, fwrite, feof, fseek, ftell, fgetcsv, stream_get_contents, etc.

Você pode usar essas funções para abrir, fechar, ler, escrever, posicionar, verificar o final, etc., de um stream.

Por exemplo, você pode usar fopen para abrir um stream, fread para ler dados do stream, fwrite para escrever dados no stream e fclose para fechar o stream.

$stream = fopen('data.txt', 'r');

while (!feof($stream)) {
$line = fgets($stream);
echo $line;
}

fwrite($stream, 'Hello World');

fclose($stream);p

Neste exemplo, estamos abrindo um arquivo chamado data.txt em modo de leitura ('r'). Em seguida, lemos o conteúdo do arquivo linha por linha até o final do arquivo com fgets. Depois, escrevemos a string Hello World no arquivo com fwrite. Por fim, fechamos o arquivo com fclose.

Você pode usar essas funções para trabalhar com streams de diferentes tipos de recursos, como o curl, sockets, pipes, etc.

$url = 'http://example.com/data/page.html';

$data = curl_init($url);

curl_setopt($data, CURLOPT_RETURNTRANSFER, true);

$response = curl_exec($data);

curl_close($data);

$stream = fopen('php://memory', 'r+');

fwrite($stream, $response);

rewind($stream);

echo stream_get_contents($stream);

fclose($stream);

Neste exemplo, estamos fazendo uma requisição HTTP com o curl para a URL http://example.com/data/page.html. Em seguida, abrimos um stream de uma variável de memória com o wrapper php em modo de leitura e escrita ('r+'). Depois, escrevemos a resposta da requisição no stream com fwrite. Por fim, exibimos o conteúdo do stream com stream_get_contents e fechamos o stream com fclose.

Stream filters

Aqui chegamos a um dos recursos mais poderosos e flexíveis dos streams em PHP: os filtros de stream.

Imagine o seguinte cenário: você está lendo dados de um arquivo e precisa processar esses dados antes de exibi-los na tela. Com os filtros de stream, você pode criar um filtro que processa os dados conforme necessário e aplicá-lo ao stream de leitura, sem precisar modificar o código que lê os dados.

Por exemplo, você pode usar um filtro de stream para converter os dados de um arquivo de texto para letras maiúsculas antes de exibi-los na tela.

$stream = fopen('data.txt', 'r');

stream_filter_append($stream, 'string.toupper');

echo stream_get_contents($stream);

fclose($stream);

Neste exemplo, estamos abrindo um arquivo chamado data.txt em modo de leitura ('r'). Em seguida, aplicamos o filtro string.toupper ao stream com stream_filter_append, que converte os dados para letras maiúsculas. Por fim, exibimos o conteúdo do stream com stream_get_contents e fechamos o arquivo com fclose.

Essa conversão é feita automaticamente pelo filtro de stream, ocorre durante a leitura dos dados e não afeta o arquivo original.

Você pode criar seus próprios filtros de stream para processar os dados de acordo com suas necessidades.

Veja a documentação oficial para mais informações sobre filtros de stream em PHP.

FilterPHP

Mas eu preparei um exemplo para você entender melhor como funciona um filtro de stream.

No primeiro exemplo, vamos criar um filtro de stream que filtrará somente para linhas que contém a palavra “PHP”.

<?php

class FilterPHP extends php_user_filter
{
public $stream;
public string $filter;

public function onCreate(): bool {
$this->stream = fopen('php://temp', 'w+');
return $this->stream !== false;
}

public function filter($in, $out, &$consumed, $closing): int {
$this->filter = 'PHP';
$out_data = '';
while ($bucket = stream_bucket_make_writeable($in)) {
$line = explode("\n", $bucket->data);
foreach ($line as $l) {
if (str_contains($l, $this->filter)) {
$out_data .= $l . "\n";
}
}
}

$bucket_out = stream_bucket_new($this->stream, $out_data);
stream_bucket_append($out, $bucket_out);

return PSFS_PASS_ON;
}
}

Vamos entender o que está acontecendo no código acima passo a passo.

1. Criamos uma classe chamada FilterPHP que estende a classe php_user_filter. Esta classe é usada para criar um filtro de stream personalizado.

Se você já trabalhou com classes em PHP, deve estar estranhando o fato de extender uma classe com um nome tão estranho. Isso acontece porque a classe php_user_filter é uma classe interna do PHP que não segue as convenções de nomenclatura de classes em PHP que foram estabelecidas pela comunidade ao longo dos anos.

1. A classe FilterPHP possui duas propriedades: $stream e $filter. A propriedade $stream é usada para armazenar um stream temporário onde os dados filtrados serão escritos. A propriedade $filter é usada para armazenar o filtro que será aplicado aos dados.
2. O método onCreate é chamado quando o filtro é criado. Neste método, abrimos um stream temporário com fopen('php://temp', 'w+') e armazenamos o recurso do stream na propriedade $stream. Se o stream não puder ser aberto, retornamos false.

O método onCreate é um método obrigatório que deve ser implementado em todos os filtros de stream personalizados, funcionando como um construtor para o filtro.

Mas o que é php://temp? php://temp é um wrapper que permite a criação de streams temporários em PHP. Os streams temporários são armazenados na memória ou em um arquivo temporário, dependendo do tamanho dos dado

3. O método filter é chamado para filtrar os dados do stream. Neste método, lemos os dados de entrada das seguintes variáveis:

• $in: stream de entrada, onde os dados originais são lidos. Este stream é somente leitura, vem de input e é passado para o filtro.
• $out: stream de saída, onde os dados filtrados são escritos. Este stream é somente escrita, vem de output e é passado para o filtro.
• &$consumed: quantidade de dados consumidos pelo filtro. Este valor é atualizado pelo filtro e passado de volta para o PHP.
• $closing: indica se o stream está sendo fechado. Se for true, o filtro deve liberar todos os recursos alocados.

Nota*: O `&` na frente de uma variável em PHP indica que a variável é passada por referência, ou seja, o valor da variável pode ser alterado dentro da função e refletido fora dela.*

4. No método filter, lemos os dados de entrada do stream com stream_bucket_make_writeable e os armazenamos na variável $out_data. Em seguida, dividimos os dados em linhas com explode("\n", $bucket->data) e verificamos se cada linha contém a palavra "PHP" com str_contains($l, $this->filter).

5. Se a linha contiver a palavra “PHP”, a linha é adicionada à variável $out_data. Em seguida, criamos um novo bucket de saída com stream_bucket_new e o adicionamos ao stream de saída com stream_bucket_append.

6. Por fim, retornamos PSFS_PASS_ON para indicar que o filtro deve continuar a passar os dados para o próximo filtro ou para o stream de saída.

Agora que criamos o filtro de stream, vamos aplicá-lo a um stream de entrada.

<?php

require_once './FilterPHP.php';

$json = 'https://raw.githubusercontent.com/sschonss/stream-php/main/data.json';

$fileContents = file_get_contents($json);

if ($fileContents === false) {
die('Failed to fetch data from the endpoint.');
}

stream_filter_register('filterphp', 'FilterPHP') or die("Failed to register filter.");

$tempStream = fopen('php://temp', 'r+');
fwrite($tempStream, $fileContents);
rewind($tempStream);

$out_fp = fopen('php://stdout', 'w') or die("Failed to open output stream.");
stream_filter_append($tempStream, 'filterphp');

while ($data = fread($tempStream, 1024)) {
$data = str_replace('"name": ', '', $data);
$data = str_replace('"description": ', '', $data);
echo $data;
}

fclose($tempStream);
fclose($out_fp);

Neste exemplo, estamos lendo um arquivo JSON de uma URL com file_get_contents e armazenando o conteúdo do arquivo em uma variável chamada $fileContents.

Em seguida, registramos o filtro de stream FilterPHP com stream_filter_register. O primeiro argumento é o nome do filtro, que será usado para aplicar o filtro ao stream de entrada. O segundo argumento é o nome da classe do filtro.

É importante registrar o filtro de stream antes de aplicá-lo ao stream de entrada, para que o PHP saiba como lidar com o filtro.

Depois, abrimos um stream temporário com fopen('php://temp', 'r+') e escrevemos o conteúdo do arquivo no stream com fwrite. Em seguida, rebobinamos o stream com rewind.

Nota*: O `rewind` é uma função que move o ponteiro interno do stream para o início do stream. Isso é necessário porque o ponteiro interno do stream é movido para o final do stream após a escrita.*

Nota*: Ponteiro em PHP é como se fosse um cursor que aponta para a posição atual do stream.*

Depois, abrimos um stream de saída com fopen('php://stdout', 'w') e aplicamos o filtro de stream FilterPHP ao stream temporário com stream_filter_append.

Por fim, lemos os dados do stream temporário com fread e exibimos os dados na tela com echo. Antes de exibir os dados, removemos as aspas duplas das chaves name e description com str_replace.

Por fim, fechamos o stream temporário e o stream de saída com fclose.

O retorno do código acima será algo como:

php-filter_1 | "PHP",
php-filter_1 | "PHP (Hypertext Preprocessor) é uma linguagem de script amplamente utilizada para desenvolvimento web e pode ser embutida em HTML."
php-filter_1 | "Composer é um gerenciador de dependências para PHP, permitindo que você declare as bibliotecas que seu projeto depende e as instale."
php-filter_1 | "Laravel é um framework web PHP, conhecido por sua sintaxe elegante e ferramentas robustas para desenvolvimento rápido de aplicativos."
php-filter_1 | "Symfony é um conjunto de componentes PHP reutilizáveis e um framework web para criar aplicações e sites."
php-filter_1 | "CodeIgniter é um framework PHP poderoso e simples de usar, construído para desenvolvedores que precisam de um toolkit elegante para criar aplicativos web completos."
php-filter_1 | "CakePHP",
php-filter_1 | "CakePHP é um framework PHP rápido de desenvolvimento que proporciona uma estrutura extensível para desenvolvedores criar aplicativos web."
php-filter_1 | "Zend Framework é uma coleção de pacotes PHP profissionais com mais de 570 milhões de instalações."

Caso você queira testar o código acima, você pode clonar o repositório stream-php e executar o comando docker-compose up para subir o container com o PHP e testar o código.

Conclusão

Streams são uma abstração poderosa e flexível para trabalhar com arquivos e outros recursos de I/O em PHP. Com streams, você pode ler e escrever dados de e para diferentes fontes, como arquivos, strings, conexões de rede, etc., de forma consistente e independente da origem ou destino dos dados.

Além disso, você pode usar contextos de stream para configurar streams com opções específicas, wrappers para abrir streams de diferentes tipos de recursos, funções de stream para trabalhar com streams de forma eficiente e filtros de stream para processar os dados conforme necessário.

Espero que este guia tenha sido útil para você entender melhor como trabalhar com streams em PHP. Se tiver alguma dúvida, sugestão ou correção, fique à vontade para entrar em contato.

Até a próxima!

Código OPC

Quando você executa um script PHP, o PHP o compila para um código intermediário chamado de código OPC (PHP Opcode). O código OPC é então executado pela máquina virtual Zend.

Segue um exemplo de código PHP e seu código OPC:

PHP:

<?php
$a = M_PI;
$b = 10 + sin($a);
echo "Result: ", $b;

Código OPC:

Finding entry points
Branch analysis from position: 0
1 jumps found. (Code = 62) Position 1 = -2
filename:       /in/ceTlX
function name:  (null)
number of ops:  9
compiled vars:  !0 = $a, !1 = $b
line      #* E I O op                           fetch          ext  return  operands
-------------------------------------------------------------------------------------
    2     0  E >   ASSIGN                                                   !0, 3.14159
    3     1        INIT_FCALL                                               'sin'
          2        SEND_VAR                                                 !0
          3        DO_ICALL                                         $3
          4        ADD                                              ~4      10, $3
          5        ASSIGN                                                   !1, ~4
    4     6        ECHO                                                     'Result%3A+'
          7        ECHO                                                     !1
    5     8      > RETURN                                                   1

Basicamente, o código OPC é uma sequência de instruções que a máquina virtual Zend executa.

JIT

Mas onde o JIT entra nisso? O JIT é um compilador que compila o código OPC em código de máquina nativo. Isso significa que o JIT compila o código OPC em código de máquina que a CPU pode executar diretamente.

Dessa forma não usamos mais a máquina virtual Zend para executar o código OPC, mas sim o código de máquina nativo gerado pelo JIT.

Habilitando o JIT

O JIT não é habilitado por padrão. Para habilitá-lo, você precisa de alguns passos adicionais.

Primeiro, você precisa instalar a extensão opcache:

sudo apt-get install php8.0-opcache

Depois, você precisa habilitar o JIT no arquivo de configuração do PHP (php.ini):

[opcache]
opcache.enable=1
opcache.jit_buffer_size=100M
opcache.jit=tracing
opcache.jit=1205
opcache.enable_cli=1

Aqui, estamos habilitando o JIT e definindo o tamanho do buffer JIT para 100 MB. O JIT pode operar em dois modos: tracing e function. O modo tracing é o modo padrão e é mais rápido, mas o modo function é mais preciso.

Para entender melhor a diferença entre os modos tracing e function, recomendo a leitura da documentação oficial.

E depois habilitamos o JIT para a linha de comando (opcache.enable_cli=1).

Benchmark

Se você roda o PHP na Web, o JIT pode não fazer muita diferença. Mas se você roda scripts PHP na linha de comando, o JIT pode trazer um grande ganho de performance.

Pois então, vamos fazer um benchmark para comparar a performance do PHP 8.0 com e sem JIT.

No repositório php-jit-doc você encontra um script PHP que calcula um monte de coisa para deixar o processador bem ocupado.

Não vamos entrar em detalhes de escrita e padrões deste script, pois o foco é o JIT.

Vamos rodar o script sem JIT:

./start.sh

O resultado foi:

Execution time: 6.2343468666077 seconds
Encrypted: 46d37684d6032ef0167c00d29f3358d5a180438d3e8604e4c11728699d78fdb0a32284bfa8234ed59f69e7febd0d23bebab983211565582a98da8cb5c8800e42

Agora vamos habilitar o JIT e rodar o script novamente:

./start-jit.sh

O resultado foi:

Execution time: 3.292811870575 seconds
Encrypted: 46d37684d6032ef0167c00d29f3358d5a180438d3e8604e4c11728699d78fdb0a32284bfa8234ed59f69e7febd0d23bebab983211565582a98da8cb5c8800e42

Com o JIT habilitado, o script PHP rodou 3 segundos mais rápido. Isso é um ganho de performance muito considerável.

Mas lembre-se, o JIT não é uma bala de prata. Ele pode não fazer muita diferença para scripts PHP que rodam na Web. Mas para scripts PHP que rodam na linha de comando, o JIT pode trazer um grande ganho de performance.

Conclusão

Esse foi um breve resumo sobre o JIT no PHP 8.0. Se você quiser saber mais sobre o JIT, recomendo a leitura da documentação oficial

Trouxe somente exemplos básicos e didáticos para que você entenda o que é o JIT e como habilitá-lo. Acho que era importante trazer esse conteúdo para o prefil para que possamos falar sobre assuntos mais complexos e avançados.

Se você gostou do conteúdo, deixe um comentário e compartilhe com seus amigos. Até a próxima!

Introdução

PHP é uma linguagem de programação de propósito geral, amplamente utilizada para desenvolvimento web. No entanto, PHP também pode ser utilizado para desenvolvimento de aplicações desktop, scripts de automação, entre outros. Neste artigo, vamos explorar o uso de PHP para programação paralela e assíncrona.

Programação Paralela

Programação paralela é um paradigma de programação que consiste em dividir um problema em partes menores que podem ser executadas simultaneamente. Em PHP, a programação paralela pode ser feita utilizando a extensão parallel ou a extensão pthreads, que permite a criação de threads em PHP.

Mas você sabe o que é uma thread?

Uma thread é uma unidade básica de processamento que pode ser executada de forma independente. Em um programa paralelo, várias threads podem ser executadas simultaneamente, o que pode resultar em um aumento significativo de desempenho.

Quando você compra um processador com múltiplos núcleos, você está comprando a capacidade de executar várias threads simultaneamente. No entanto, para aproveitar ao máximo essa capacidade, é necessário que o software seja desenvolvido de forma a utilizar esses recursos de forma eficiente.

Exemplo de Programação Paralela em PHP

<?php

use function parallel\run;

class DataProcessor
{
public function process(array $data): array {
$formattedData = $this->formatData($data);
$excel_file = $this->generateExcel($formattedData);
$this->sendEmail($excel_file, Auth::user()->email);
}
}

$data = range(1, 1000);

$processor = new DataProcessor();

$parallelResult1 = run(function () use ($processor, $data) {
return $processor->process($data);
});

$parallelResult2 = $processor->process($data);

No exemplo acima, estamos utilizando a extensão parallel para executar o método process da classe DataProcessor em paralelo. Isso significa que o método será executado em uma thread separada, o que pode resultar em um aumento de desempenho.

Isso não é bala de prata, e nem sempre é a melhor solução para todos os problemas. No entanto, em alguns casos, a programação paralela pode ser uma forma eficiente de melhorar o desempenho de uma aplicação.

O exemplo acima é bastante simplificado, mas ilustra como a programação paralela pode ser utilizada em PHP. Para obter mais informações sobre a extensão parallel, consulte a documentação oficial.

Aqui esta uma imagem de um exemplo de programação paralela em PHP:

Imagem ilustrativa de um exemplo de programação paralela retirada da internet.

Perceba que a programação paralela é diferente da programação assíncrona. Na programação paralela, várias threads são executadas simultaneamente, enquanto na programação assíncrona, várias tarefas podem ser executadas de forma concorrente, mas não necessariamente simultaneamente.

Programação Assíncrona

Programação assíncrona é um paradigma de programação que consiste em executar tarefas de forma concorrente, sem a necessidade de esperar que uma tarefa seja concluída para iniciar outra. Em PHP, a programação assíncrona pode ser feita utilizando a extensão swoole, que permite a criação de servidores web assíncronos em PHP.

Mas você sabe o que é um servidor web assíncrono?

Um servidor web assíncrono é um servidor que pode lidar com várias requisições simultaneamente, sem a necessidade de criar uma nova thread para cada requisição. Isso permite que o servidor seja mais eficiente e possa lidar com um grande número de requisições de forma concorrente.

Você pode achar o termo “servidor auto-contido” em alguns lugares, mas a ideia é a mesma: um servidor que pode lidar com várias requisições simultaneamente, sem a necessidade de criar uma nova thread para cada requisição.

Exemplo de Programação Assíncrona em PHP

use Swoole\Http\Server;

$server = new Server("0.0.0.0", 9501);

$server->on("start", function (Server $server) {
echo "Server started at http://{$server->host}:{$server->port}\n";
});

$server->on("request", function ($request, $response) {
$data = $request->rawContent();
$response->end("Received data: $data");
});

$server->start();

No exemplo acima, estamos utilizando a extensão swoole para criar um servidor web assíncrono em PHP. O servidor irá escutar na porta 9501 e responder a todas as requisições com uma mensagem contendo os dados recebidos

Esse exemplo é bastante simplificado, mas ilustra como a programação assíncrona pode ser utilizada em PHP. Para obter mais informações sobre a extensão swoole, consulte a documentação oficial.

Aqui esta uma imagem de um exemplo de programação assíncrona:

Imagem ilustrativa de um exemplo de programação assíncrona retirada da internet.

Ciclo de Vida de uma Requisição no PHP-FPM

Quando uma requisição é feita a um servidor web PHP, como o PHP-FPM, o servidor passa por várias etapas para processar a requisição e retornar uma resposta ao cliente. O ciclo de vida de uma requisição no PHP-FPM pode ser dividido em várias etapas:

1. Recebimento da Requisição: O servidor web (Apache, Nginx, etc.) recebe a requisição do cliente e a encaminha para o PHP-FPM.
2. Pool de Processos: O PHP-FPM mantém um pool de processos PHP pré-carregados para processar as requisições. Quando uma requisição é recebida, o PHP-FPM escolhe um processo disponível para processar a requisição.
3. Autoload: O PHP-FPM carrega os arquivos necessários para processar a requisição, incluindo as classes e funções utilizadas no script PHP. As classes e funções são carregadas automaticamente pelo PHP, de acordo com as regras de autoload definidas no arquivo composer.json.
4. Análise e Compilação: O PHP analisa o script PHP e compila o código em uma forma que pode ser executada pelo interpretador PHP.
5. Execução do Script: O PHP executa o script PHP, processando as instruções e gerando a saída da requisição.
6. Gerar Resposta: O PHP-FPM gera a resposta da requisição, incluindo o cabeçalho HTTP e o corpo da resposta.
7. Envio da Resposta: O PHP-FPM envia a resposta ao servidor web, que a encaminha de volta ao cliente.
8. Encerramento do Processo: Após enviar a resposta, o processo PHP é encerrado e retorna ao pool de processos disponíveis para processar novas requisições.

O ciclo de vida de uma requisição no PHP-FPM pode variar dependendo da configuração do servidor web e do PHP-FPM. No entanto, essas etapas são comuns na maioria dos servidores web PHP.

Ciclo de Vida de uma Requisição no Swoole

Quando uma requisição é feita a um servidor web assíncrono PHP, como o Swoole, o servidor passa por várias etapas para processar a requisição e retornar uma resposta ao cliente. O ciclo de vida de uma requisição no Swoole pode ser dividido em várias etapas:

O início do ciclo de vida de uma requisição no Swoole começa com a inicialização do servidor Swoole e a configuração do script PHP que será executado para processar as requisições. O servidor Swoole escuta em uma porta específica e aguarda a chegada de requisições.

Nesse ponto, o servidor já está com o autoload configurado, as classes e funções necessárias já estão carregadas e o script PHP está pronto para processar as requisições.

1. Recebimento da Requisição: Quando uma requisição é feita ao servidor Swoole, o servidor recebe a requisição e a encaminha para o script PHP configurado para processar a requisição.
2. Processamento da Requisição: O script PHP processa a requisição, executando as instruções necessárias para gerar a resposta da requisição.
3. Análise e Compilação: O PHP analisa o script PHP e compila o código em uma forma que pode ser executada pelo interpretador PHP.
4. Execução do Script: O PHP executa o script PHP, processando as instruções e gerando a saída da requisição.
5. Gerar Resposta: O script PHP gera a resposta da requisição, incluindo o cabeçalho HTTP e o corpo da resposta.
6. Envio da Resposta: O servidor Swoole envia a resposta ao cliente, encerrando o ciclo de vida da requisição.

E nesse momento, o servidor Swoole está pronto para processar novas requisições, mantendo um pool de processos PHP disponíveis para processar as requisições de forma assíncrona.

A diferença entre o ciclo de vida de uma requisição no PHP-FPM e no Swoole está na forma como o servidor PHP é inicializado e como as requisições são processadas. No PHP-FPM, o servidor PHP é inicializado para processar uma única requisição de cada vez, enquanto no Swoole, o servidor PHP é inicializado para processar várias requisições de forma assíncrona.

Conclusão

Neste artigo, exploramos o uso de PHP para programação paralela e assíncrona. A programação paralela e assíncrona são técnicas de programação que podem ser utilizadas para melhorar o desempenho de uma aplicação e lidar com um grande número de requisições de forma eficiente.

Nem tudo é regra, e nem sempre a programação paralela ou assíncrona é a melhor solução para um problema. No entanto, é sempre bom conhecer as diferentes técnicas de programação disponíveis e saber quando utilizá-las de forma eficiente.

Espero que este artigo tenha sido útil e que você tenha aprendido algo novo sobre programação paralela e assíncrona em PHP. Espero que futuramente eu consiga fazer um artigo mais detalhado sobre cada uma dessas técnicas, com exemplos mais complexos e detalhados.

Qualquer dúvida, correção ou sugestão, fique à vontade para entrar em contato. Obrigado por ler até aqui!

Referências

• PHP Parallel Extension
• PHP pthreads Extension
• Swoole Extension
• PHP-FPM
• PHP Autoload
• PHP Composer
• PHP PSR
• FastCGI

Autor

• Luiz Schons

Sua principal função é, a partir de uma chave simples, fazer uma busca rápida e eficiente para encontrar o valor desejado.

1. Funções Hash

1.1. Introdução

A função hash é uma função que, a partir de uma entrada de dados, gera um valor numérico que identifica a posição de um elemento em uma tabela hash.

Nós já vimos algumas outras estruturas de dados aqui nesse perfil, como buscar um elemento em uma lista encadeada ou em uma árvore binária, e vimos que a complexidade dessas operações é O(n) e O(log n), respectivamente.

A tabela hash, por sua vez, consegue fazer essa busca em O(1), ou seja, em tempo constante.

Isso significa que, não importa o tamanho da tabela, a busca será feita no mesmo tempo.

1.2. Exemplo

Muitas vezes, a função hash é usada para criar um índice para um array, e é por isso que a função hash deve ser rápida e eficiente.

Desenvolvi uma função hash muito simples, que pega uma palavra e retorna um número que representa essa palavra.

package main

import (
"fmt"
)

func main() {
for {
run()
}
}

func run(){
array_palavras := [10000]string{}
fmt.Println("Digite uma palavra para ser hasheada")
var palavra string
fmt.Scanln(&palavra)
hash_palavra := fake_hash(palavra)
fmt.Println("A palavra", palavra, "tem o hash", hash_palavra)
array_palavras[hash_palavra] = palavra
fmt.Println("A palavra", palavra, "foi adicionada ao array na posicao", hash_palavra)
fmt.Println("Digite um hash para buscar a palavra correspondente")
var hash int
fmt.Scanln(&hash)
fmt.Println("A palavra correspondente ao hash", hash, "é", array_palavras[hash])
}

func fake_hash(palavra string) int {
hash := 0
for i := 0; i < len(palavra); i++ {
hash += int(palavra[i])
}
return hash
}

Nesse exemplo, a função fake_hash pega a palavra e soma os valores ASCII de cada caractere, retornando um número que representa a palavra.

Mas fique tranquilo, provavelmente você não vai precisar criar uma função hash, pois as linguagens de programação já possuem funções hash prontas e otimizadas.

Pode ser que na sua linguagem de programação a função hash seja chamada de outra coisa, como “map” ou “dicionário”, mas o conceito é o mesmo.

2. Usabilidade

2.1. Lista Telefônica

Um exemplo clássico de uso de tabela hash é a lista telefônica.

Imagine que você quer encontrar o número de telefone de uma pessoa.

Se a lista telefônica fosse uma lista encadeada, você teria que percorrer toda a lista até encontrar o nome da pessoa.

Se fosse uma árvore binária, você teria que percorrer a árvore até encontrar o nome da pessoa.

Mas, como a lista telefônica é uma tabela hash, você pode encontrar o número de telefone de uma pessoa em tempo constante, ou seja, em O(1).

Vamos entender mais sobre isso.

Ao adicionar um nome e um número de telefone à lista telefônica, a função hash é usada para gerar um índice para esse nome.

Quando você quer encontrar o número de telefone de uma pessoa, a função hash é usada para gerar o índice correspondente ao nome da pessoa, e o número de telefone é retornado.

Dessa forma:

package main

import (
"fmt"
)
func main() {
lista_telefonica := make(map[string]string)
lista_telefonica["João"] = "1234-5678"
lista_telefonica["Maria"] = "8765-4321"
lista_telefonica["José"] = "4321-5678"
lista_telefonica["Ana"] = "5678-4321"
fmt.Println("O número de telefone de João é", lista_telefonica["João"])
fmt.Println("O número de telefone de Maria é", lista_telefonica["Maria"])
fmt.Println("O número de telefone de José é", lista_telefonica["José"])
fmt.Println("O número de telefone de Ana é", lista_telefonica["Ana"])
}

Nesse exemplo, a função hash é usada para gerar um índice para cada nome, e o número de telefone é retornado em tempo constante.

2.2. DNS

Outro exemplo clássico de uso de tabela hash é o DNS (Domain Name System).

O DNS é um sistema que traduz nomes de domínio da Internet em endereços IP.

Imagine que você quer acessar um site, como www.google.com.

Se o DNS não fosse uma tabela hash, você teria que percorrer toda a lista de domínios até encontrar o nome do site, imagina o tempo que isso levaria.

Mas, como o DNS é uma tabela hash, você pode encontrar o endereço IP de um site em tempo constante, ou seja, em O(1).

Vamos entender mais sobre isso com um exemplo.

package main

import (
"fmt"
)
func main() {
dns := make(map[string]string)
dns["www.google.com"] = "192.168.5.5"
dns["www.facebook.com"] = "192.168.40.21"
dns["www.twitter.com"] = "192.168.11.11"
fmt.Println("O endereço IP de www.google.com é", dns["www.google.com"])
fmt.Println("O endereço IP de www.facebook.com é", dns["www.facebook.com"])
fmt.Println("O endereço IP de www.twitter.com é", dns["www.twitter.com"])
}

Entende como são exemplos bem similares? A ideia é a mesma, a tabela hash é usada para gerar um índice para cada nome, e o endereço IP é retornado em tempo constante.

3. Colisões

3.1. Introdução

Uma colisão ocorre quando duas chaves de pesquisa diferentes têm o mesmo valor hash.

Mas isso é possível? Como a função hash gera um valor único para cada chave de pesquisa?

Bom, a função hash não gera um valor único para cada chave de pesquisa, ela gera um valor que representa a chave de pesquisa.

E, como o número de chaves de pesquisa é muito maior do que o número de valores hash, é possível que duas chaves de pesquisa diferentes tenham o mesmo valor hash.

3.2. Tratamento de Colisões

Existem várias maneiras de tratar colisões, mas as duas mais comuns são:

• Encadeamento
• Endereçamento Aberto

3.2.1. Encadeamento

No encadeamento, cada entrada da tabela hash é uma lista encadeada.

Quando ocorre uma colisão, a chave de pesquisa é adicionada à lista encadeada correspondente.

Isso significa que, se duas chaves de pesquisa diferentes têm o mesmo valor hash, elas são adicionadas à mesma lista encadeada.

A principal vantagem do encadeamento é que ele é simples de implementar, mas a principal desvantagem é que ele pode ser ineficiente em termos de espaço e desempenho.

3.2.2. Endereçamento Aberto

No endereçamento aberto, quando ocorre uma colisão, a chave de pesquisa é adicionada a outra posição da tabela hash.

Isso significa que, se duas chaves de pesquisa diferentes têm o mesmo valor hash, a segunda chave de pesquisa é adicionada a outra posição da tabela hash.

A principal vantagem do endereçamento aberto é que ele é eficiente em termos de espaço e desempenho, mas a principal desvantagem é que ele é mais complexo de implementar.

4. Desempenho

4.1. Fator de Carga

O fator de carga é a razão entre o número de chaves de pesquisa e o número de posições da tabela hash.

Quanto maior o fator de carga, maior a probabilidade de colisões.

Por isso, é importante manter o fator de carga baixo, para garantir um bom desempenho da tabela hash.

Um fator de carga ideal é menor que 0,7, ou seja, menos de 70% das posições da tabela hash estão ocupadas.

4.1.1. Como Calcular o Fator de Carga

O fator de carga é calculado da seguinte forma:

NK = número de chaves de pesquisa
NP = número de posições da tabela hash

NK / NP = fator de carga

Por exemplo, se a tabela hash tem 100 posições e 70 chaves de pesquisa, o fator de carga é 0,7.

70 / 100 = 0,7

4.2. Redimensionamento

Quando o fator de carga é maior que 0,7, é necessário redimensionar a tabela hash.

O redimensionamento da tabela hash é feito da seguinte forma:

• Crie uma nova tabela hash com o dobro do tamanho da tabela hash original
• Adicione todas as chaves de pesquisa da tabela hash original à nova tabela hash
• Descarte a tabela hash original

O redimensionamento da tabela hash é uma operação custosa, mas é necessária para garantir um bom desempenho da tabela hash.

5. SHA

SHA (Secure Hash Algorithm) é uma família de funções hash criptográficas.

Ela é uma ótima função hash, pois gera um valor único para cada chave de pesquisa.

SHA é amplamente utilizada em criptografia, segurança da informação e autenticação.

SHA é uma função hash muito segura, e é praticamente impossível encontrar duas chaves de pesquisa diferentes com o mesmo valor hash.

Uma das principais vantagens de SHA é que ela é rápida, eficiente e unidirecional, ou seja, é fácil calcular o valor hash de uma chave de pesquisa, mas é praticamente impossível calcular a chave de pesquisa a partir do valor hash.

Segue um exemplo de como usar SHA em Go:

package main
import (
"crypto/sha256"
"fmt"
)

func main() {
palavra := "hello"
hash := sha256.Sum256([]byte(palavra))
fmt.Printf("O hash de %s é %x\n", palavra, hash)
}

Nesse exemplo, a função hash SHA-256 é usada para gerar um valor hash para a palavra “hello”.

Mas se você quiser usar o SHA-256 para gerar a palavra “hello” a partir do valor hash, você não vai conseguir.

6. Conclusão

As tabelas hash são estruturas de dados muito eficientes para fazer buscas rápidas e eficientes.

Elas são amplamente utilizadas em aplicações do mundo real, como listas telefônicas, DNS, criptografia e segurança da informação.

Você aprendeu sobre funções hash, usabilidade, colisões, desempenho e SHA.

Nunca implemente uma função hash e use em produção, sempre use funções hash prontas e otimizadas da sua linguagem de programação.

Espero que você tenha aprendido bastante sobre tabelas hash, e que você possa aplicar esse conhecimento em suas aplicações do mundo real.

Se você tiver alguma dúvida ou sugestão, deixe nos comentários.

Até a próxima!

Mas antes de começarmos a falar sobre o algoritmo, você precisa entender o que são métodos de DC (Divisão e Conquista).

Métodos de DC

Métodos de DC são algoritmos que resolvem um problema dividindo-o em subproblemas, resolvendo os subproblemas recursivamente e combinando as soluções dos subproblemas para resolver o problema original.

Vamos ver um exemplo de um algoritmo que utiliza DC.

Exemplo

Imagina que você tenha um array de inteiros e quer saber a soma de todos os elementos desse array. Você pode resolver esse problema utilizando DC da seguinte forma:

Array: [1, 2, 3, 4, 5]

Qual é o caso base? O caso base é quando o array tem apenas um elemento. Nesse caso, a soma é o próprio elemento.

Como iremos chegar no caso base? Vamos remover um elemento e ver o que sobra.

Agora que chegamos no caso base, vamos resolver o problema. A soma de todos os elementos do array [5] é 5. Agora, vamos somar o 4 que removemos anteriormente. A soma de todos os elementos do array [4, 5] é 9. Agora, vamos somar o 3 que removemos anteriormente. A soma de todos os elementos do array [3, 9] é 12. E assim por diante.

A soma de todos os elementos do array [1, 2, 3, 4, 5] é 15.

Esse é um caso simples de DC e muitos algoritmos utilizam esse conceito para resolver problemas.

Por que não usar um loop?

Você pode estar se perguntando por que não usar um loop para resolver esse problema. E a resposta é: você pode! Mas, em alguns casos, a solução utilizando DC é mais simples e mais fácil de entender.

Outro ponto importante é que, em algumas linguagens, principalmente as funcionais, não existe a estrutura de repetição (for, while, etc). Então, a única forma de resolver um problema é utilizando DC.

Entendendo esse algoritimo, você consegue trabalhar com outras linguagens de programação e entender como elas funcionam.

Caso tenha alguma dúvida, busque por mais exemplos e tente resolver problemas utilizando DC.

Quicksort

Agora que você entendeu o que é DC, vamos falar sobre o Quicksort.

O Quicksort é um algoritmo de ordenação muito eficiente, inventado por C.A.R. Hoare em 1960. Ele é amplamente utilizado para ordenação de arrays. O algoritmo que apresentamos a seguir é uma versão recursiva do Quicksort que seleciona um elemento como pivô e particiona o array de forma que todos os elementos menores que o pivô fiquem antes dele e os maiores fiquem depois. Os subarrays são então ordenados recursivamente.

Exemplo

Vamos ver um exemplo de como o Quicksort funciona.

Passo 1: Escolha um elemento como pivô. Vamos escolher o 6.

Passo 2: Particione o array de forma que todos os elementos menores que o pivô fiquem antes dele e os maiores fiquem depois.

Passo 3: Ordenar os subarrays recursivamente.

O que significa ordenar os subarrays recursivamente? Significa que vamos repetir os passos 1 e 2 para os subarrays, escolhendo um pivô e particionando o array.

Vamos escolher o 1 como pivô.

Vamos escolher o 2 como pivô.

Agora somos obrigados a escolher o 3 como pivô.

Agora que chegamos no caso base, vamos ordenar os subarrays recursivamente.

Voltando agora os arrays até organizarmos o array da esquerda.

Agora vamos organizar o array da direita.

Passo 1: Escolha um elemento como pivô. Vamos escolher o 10.

Passo 2: Particione o array de forma que todos os elementos menores que o pivô fiquem antes dele e os maiores fiquem depois.

Agora que chegamos no caso base, vamos ordenar os subarrays recursivamente.

Voltando agora os arrays até organizarmos o array da direita.

Agora que organizamos os subarrays, o array original está ordenado.

Esse é um exemplo de como o Quicksort funciona.

Performance

Dentro do desenvolvimento de software, a performance é um fator muito importante e muitas vezes usamos a Notação Big O para descrever a eficiência de um algoritmo.

Caso você não conheça a Notação Big O, recomendo que você leia um artigo sobre o assunto que escrevi aqui nesse link: Notação Big O.

O desempenho do Quicksort é O(n log n) no melhor caso e O(n²) no pior caso.

E a performance vai depender do pivô que você escolher. Se você escolher um pivô que seja o menor ou o maior elemento do array, o desempenho do Quicksort será O(n²). Mas, se você escolher um pivô que seja o elemento do meio do array, a performance do Quicksort será O(n log n).

Mas como escolher o pivô? Existem várias formas de escolher o pivô e a escolha do pivô vai depender do seu problema. Uma forma de escolher o pivô é escolher o elemento do meio do array.

Dessa forma, eu fiz um repositório no github com a implementação do Quicksort em Go. Caso você queira ver a implementação, clique aqui.

Esse artigo é uma introdução ao Quicksort e espero que você tenha entendido como o algoritmo funciona, e agora se você escutar alguém falando sobre Quicksort, você vai entender do que se trata.

Lembre-se que a prática leva a perfeição e, quanto mais você praticar, mais você vai entender sobre o assunto.

Caso tenha alguma dúvida, busque por mais exemplos e tente resolver problemas utilizando Quicksort.

Espero que você tenha gostado do artigo e até a próxima!

Aqui nesse perfil já falamos sobre diversos assuntos, como, por exemplo:

• Licenças de software
• Cache em Aplicações Web
• Over Engineering
• e muito mais…

Mas hoje vamos falar sobre um assunto que é muito importante para a disponibilidade de aplicações web, o balanceamento de carga.

O que é balanceamento de carga?

Se você está começando a trabalhar com desenvolvimento web, provavelmente nunca ouviu falar sobre balanceamento de carga, e tenha calma, pois é um assunto bem simples.

Diferente do que aprendemos na faculdade ou em cursos, onde aprendemos a desenvolver aplicações web que rodam em um único servidor, na realidade, aplicações web rodam em mais de um servidor, e isso é necessário para que a aplicação tenha uma boa disponibilidade.

Por que utilizar mais de um servidor?

No início do desenvolvimento temos um servidor só, e isso é o suficiente para que a aplicação funcione corretamente, mas quando a aplicação começa a crescer, e o número de acessos aumenta, um único servidor não é mais o suficiente para atender a demanda, e é aí que entra um termo muito importante, escalabilidade.

A escalabilidade é a capacidade de uma aplicação de aumentar a sua capacidade de atender a demanda.

Existem dois tipos de escalabilidade, a vertical e a horizontal.

Escalabilidade vertical

A escalabilidade vertical é quando aumentamos a capacidade de um servidor, adicionando mais memória, processamento, etc.

Chamamos isso de escalabilidade vertical, pois estamos aumentando a capacidade de um único servidor.

Escalabilidade horizontal

A escalabilidade horizontal é quando aumentamos a capacidade de uma aplicação, adicionando mais servidores.

Chamamos isso de escalabilidade horizontal, seria algo como colocar mais servidores ao lado do servidor que já temos.

Como funciona o balanceamento de carga?

Quando temos mais de um servidor, precisamos de um mecanismo para distribuir as requisições entre os servidores, e esse mecanismo é o balanceador de carga.

O balanceador de carga é um servidor que fica na frente dos servidores que rodam a aplicação, e ele é responsável receber as requisições e distribuir.

Um detalhe importante é que o balanceador de carga não é um servidor comum, ele é um servidor especializado, que tem como única função, distribuir as requisições entre os servidores que rodam a aplicação.

Como funciona o balanceamento de carga?

Geralmente rodando na porta 80, o balanceador fica a frente dos servidores, nele é configurado o endereço de onde rodam a aplicação, e ele é responsável por distribuir as requisições entre os servidores conforme a sua configuração de balanceamento.

Existem vários tipos de balanceamento, mas os mais comuns são:

• Round Robin
• Least Connections
• Least Response Time
• Hash
• IP Hash

Round Robin

O balanceamento Round Robin é o mais simples, ele distribui as requisições entre os servidores de forma circular, ou seja, a primeira requisição vai para o servidor 1, a segunda para o servidor 2, a terceira para o servidor 3, e assim por diante.

Least Connections

Distribui as requisições entre os servidores conforme o número de conexões ativas em cada servidor, ou seja, se o servidor 1 tem 10 conexões ativas, e o servidor 2 tem 5 conexões ativas, a próxima requisição vai para o servidor 2, pois ele tem menos conexões ativas.

Least Response Time

Distribui as requisições entre os servidores segundo o tempo de resposta de cada servidor, ou seja, se o servidor 1 tem um tempo de resposta de 100ms, e o servidor 2 tem um tempo de resposta de 50ms, a próxima requisição vai para o servidor 2, pois ele tem um tempo de resposta menor.

Hash

Distribui as requisições entre os servidores de acordo com um hash gerado a partir de um parâmetro da requisição, por exemplo, se o parâmetro for TOKEN, e o valor do TOKEN for 123, o hash gerado será sempre o mesmo, e a requisição sempre vai para o mesmo servidor.

IP Hash

Distribui as requisições entre os servidores conforme o IP do cliente, ou seja, todas as requisições que vierem do mesmo IP, vão para o mesmo servidor.

Qual balanceamento utilizar?

Não existe um balanceamento melhor que o outro, cada um tem a sua aplicação, e o ideal é que você teste cada um deles, e veja qual se adapta melhor a sua aplicação.

Quando balancear a carga?

O balanceamento de carga é utilizado quando temos mais de um servidor, e precisamos distribuir as requisições entre eles, mas quando temos apenas um servidor, não temos a necessidade de utilizar um balanceador de carga, pois ele só iria adicionar mais um ponto de falha na aplicação.

Lembre-se que nos servidores devem rodar a mesma aplicação, e devem estar sincronizados, pois se um servidor estiver com uma versão diferente da aplicação, ele pode apresentar comportamentos inesperados.

Geralmente usa-se o balanceamento de carga quando temos mais de um droplet, e cada droplet roda a mesma aplicação, e temos um banco de dados centralizado, acessado por todos.

Serviços de balanceamento de carga

Existem vários serviços de balanceamento de carga, mas os mais conhecidos são:

• Nginx
• HAProxy
• Apache
• AWS Elastic Load Balancer
• Google Cloud Load Balancing
• Azure Load Balancer
• E muitos outros…

Todos eles são ótimos, e cada um tem a sua aplicação, mas o mais utilizado é o Nginx, pois ele é muito leve, e tem um ótimo desempenho.

Conclusão

O balanceamento de carga é um assunto muito importante, e é essencial para que a aplicação tenha uma boa disponibilidade, e não fique fora do ar.

Caso tenha alguma dúvida, ou queira contribuir com o artigo, deixe um comentário abaixo.

Provavelmente você já ouviu falar do rand() ou do random() em alguma linguagem de programação, certo? Essas funções servem para gerar números aleatórios, porém será que eles são realmente aleatórios?

Hoje vamos falar sobre o que é um PRNG e como ele funciona.

Exemplo de número aleatório

A linguagem que vamos usar para exemplificar os números aleatórios é o JavaScript, porém o conceito é o mesmo para qualquer linguagem. Escolhi o JavaScript, pois você pode executar o código diretamente no seu navegador.

O código abaixo gera um número aleatório entre 0 e 1.

Math.random()

Se você executar o código acima no seu navegador, você vai perceber que ele sempre vai gerar um número aleatório diferente, mas será que ele é realmente aleatório?

O que é um PRNG?

PRNG é a sigla para Pseudo Random Number Generator, ou seja, Gerador de Números Pseudo Aleatórios.

O que isso significa? Significa que o número gerado não é realmente aleatório, ele é gerado a partir de um algoritmo que usa uma semente (seed) para gerar o número.

O que é uma semente?

A semente é um valor usado como base para gerar o número aleatório. Se você usar a mesma semente, o número gerado será sempre o mesmo.

Como funciona um PRNG?

Um PRNG funciona a partir de uma função que recebe uma variável(semente/seed) e retorna um número aleatório. A função deve ser capaz de gerar um número aleatório a partir de uma semente.

Exemplo de PRNG

Vamos criar um PRNG simples que recebe uma semente e retorna um número aleatório entre 0 e 1.

function prng(seed) {
return (seed * 9301 + 49297) % 233280 / 233280;
}

A função acima é um PRNG simples que recebe uma semente e retorna um número aleatório entre 0 e 1.

Exemplo de uso do PRNG

Vamos usar o PRNG que criamos para gerar um número aleatório entre 0 e 1.

prng(1)

Se você executar o código acima no seu navegador, você vai perceber que ele sempre vai gerar o mesmo número aleatório, pois estamos usando a mesma semente.

Mas como é gerado a semente?

A semente é gerada a partir de um valor gerado pelo sistema operacional. Esse valor é chamado de entropia.

O que é entropia?

Em termos gerais, refere-se à quantidade de incerteza em um sistema. Quanto maior a entropia, maior a incerteza. Isso não é exclusivo da computação, mas também se aplica a outras áreas, como física e química.

Como é gerado a entropia no sistema operacional?

A entropia é gerada a partir de eventos aleatórios que ocorrem no sistema operacional, como movimento do mouse, pressionamento de teclas, etc.

Como é gerado a semente a partir da entropia?

No nosso exemplo, a entropia é gerada a partir dos movimentos do mouse e pressionamento de teclas. Esses eventos são capturados pelo sistema operacional e convertidos em um valor numérico usado como semente.

É possível controlar a entropia?

Sim, é possível controlar a entropia. Por exemplo, se você mover o mouse de forma aleatória, você vai gerar mais entropia do que se você mover o mouse de forma previsível.

De forma geral, quanto mais aleatório for o evento, maior será a entropia gerada.

Então o PRNG é realmente aleatório?

Em resumo, os números gerados por PRNGs em linguagens de programação não são verdadeiramente aleatórios, mas são suficientes para muitas aplicações do dia a dia. Se você precisar de aleatoriedade verdadeira, pode ser necessário recorrer a fontes de entropia real ou serviços externos de geração de números aleatórios.

O que é um CSPRNG?

CSPRNG é a sigla para Cryptographically Secure Pseudo Random Number Generator, ou seja, Gerador de Números Pseudo Aleatórios Criptograficamente Seguros.

Embora os PRNGs sejam adequados para muitas aplicações, eles não são adequados para aplicações que exigem uma entropia mais elevada, como criptografia. Para essas aplicações, é necessário usar um CSPRNG.

Características de um CSPRNG

Um CSPRNG deve ter as seguintes características:

- Deve ser imprevisível

Mesmo que você conheça o algoritmo e a semente, você não deve ser capaz de prever o próximo número gerado. Isso é fundamental para a segurança.

- Ampla Entropia

Um CSPRNG deve ter uma ampla entropia, ou seja, deve ser capaz de gerar números aleatórios a partir de uma ampla gama de fontes de entropia.

- Repetibilidade Controlada

Um CSPRNG deve ser capaz de gerar os mesmos números aleatórios a partir da mesma semente. Isso é importante para testes e depuração.

Exemplo de CSPRNG

Algumas linguagens de programação já possuem um CSPRNG embutido, como no PHP.

ramdom_bytes();

Ou então Python com o módulo secrets.

import secrets

secrets.randbits(16)

Caraca, não entendi nada!

Calma, não se preocupe. O objetivo desse artigo é apenas explicar o que é um PRNG e como ele funciona. Se você não entendeu alguma coisa, não se preocupe, o importante é que você entenda o conceito.

Agora que você já sabe o que é um PRNG, você pode pesquisar mais sobre o assunto e aprender mais sobre o funcionamento de um PRNG.

O importante é que você saia daqui sabendo os seguintes conceitos:

• Meus números aleatórios são realmente aleatórios?
• O que é um PRNG?
• Como funciona um PRNG?
• O que é uma semente?
• O que é entropia?
• O que é um CSPRNG?

O mundo da programação é muito vasto e sempre temos algo novo para aprender.

Conclusão

Talvez você esteja se perguntando: “Mas eu preciso saber disso?”. A resposta é: “Depende”. (já ouviu essa resposta antes né?)

Possa ser que você nunca precise usar um PRNG na sua vida, mas é sempre bom saber como as coisas funcionam por baixo dos panos, além de ser uma curiosidade interessante.

É possível que esse artigo tenha ficado um pouco confuso, pois ainda estou começando a estudar sobre o assunto, mas espero que você tenha entendido o conceito básico de um PRNG.

Se você gostaria de complementar esse artigo, sinta-se a vontade para fazer um comentário ou até mesmo entrar em contato comigo.

Até a próxima!

O que é cache?

Cache é um mecanismo de armazenamento temporário de dados. Ele é utilizado para que o acesso a esses dados seja mais rápido, pois o cache fica armazenado em uma memória mais rápida do que a memória principal. Porém, o cache é um espaço limitado, então ele só armazena os dados que são mais acessados.

Como funciona o cache?

Basicamente, o cache funciona da seguinte forma: quando um dado é acessado pela primeira vez, ele é armazenado no cache. Quando esse dado é acessado novamente, ele é retornado do cache, sem a necessidade de acessar o local onde ele está armazenado originalmente. Isso faz com que o tempo de resposta seja menor.

Bala de prata?

Apesar de ser uma ótima forma de otimizar uma aplicação, o cache não é uma bala de prata. Ele não é capaz de resolver todos os problemas de performance de uma aplicação. Por exemplo, se o cache for mal utilizado, ele pode acabar piorando a performance da aplicação e até mesmo causando problemas de segurança.

Ferramentas

Existem diversas ferramentas que podem ser utilizadas para implementar cache em uma aplicação web. Algumas delas são:

• Redis
• Memcached
• Varnish
• E muitas outras…

Cada uma dessas ferramentas tem suas vantagens e desvantagens, e a escolha de qual utilizar vai depender do contexto da aplicação.

A mais utilizada é o Redis, que é um banco de dados NoSQL em memória. Ele é muito rápido e possui diversas estruturas de dados que podem ser utilizadas para armazenar os dados em cache.

Banco de dados em memória?

Sim, o Redis é um banco de dados em memória. Isso significa que os dados armazenados nele não são persistidos em disco, ou seja, salvo na memória principal do computador. Por isso, é necessário ter cuidado ao utilizar o Redis, pois se o computador for desligado, os dados armazenados nele serão perdidos, a menos que seja configurado para persistir os dados em disco, mas isso é assunto para outro artigo.

Situações em que o cache pode ser utilizado

O cache pode ser utilizado em diversas situações, como por exemplo:

Cache de sessão

Quando um usuário faz login em uma aplicação web, é necessário que o servidor armazene as informações da sessão desse usuário, para que ele não precise fazer login novamente a cada requisição. Porém, se a aplicação tiver milhares de usuários, armazenar as informações de sessão de todos eles pode acabar consumindo muita memória do servidor. Para evitar isso, é possível armazenar as informações de sessão em um banco de dados em memória, como o Redis.

Cache de dados

Quando uma aplicação web precisa acessar um banco de dados, ela faz uma requisição ao banco de dados, que retorna os dados solicitados. Porém, se esses dados forem acessados com muita frequência, é possível armazená-los em um cache para que eles sejam retornados mais rapidamente. Dessa forma, a aplicação não precisa acessar o banco de dados toda vez que precisar desses dados, isso faz com que o tempo de resposta seja menor, o custo de consulta ao banco de dados seja reduzido e a carga no banco de dados seja menor.

Cache de arquivos

Servir arquivos estáticos, como imagens, CSS e JavaScript, é uma das tarefas mais comuns de uma aplicação web. Porém, se esses arquivos forem acessados com muita frequência, é possível armazená-los em um cache para que eles sejam retornados mais rapidamente. Dessa forma, a aplicação não precisa acessar o disco toda vez que precisar desses arquivos, isso faz com que o tempo de resposta seja menor e a carga no disco seja menor. Existem diversas formas de fazer isso, como por exemplo:

• Utilizar um servidor de arquivos estáticos, como o Nginx, para servir esses arquivos.
• Utilizar um CDN (Content Delivery Network) para servir esses arquivos.
• Utilizar um serviço de armazenamento em nuvem, como o Amazon S3, para armazenar esses arquivos.

Quando não utilizar cache?

Como dito anteriormente, o cache não é uma bala de prata. Usar em excesso pode acabar prejudicando o seu software.

Vou citar alguns exemplos de quando não utilizar cache:

Dados que são atualizados com frequência

Se os dados que estão sendo armazenados em cache são atualizados com muita frequência, o cache pode acabar ficando desatualizado, o que pode causar problemas na aplicação. Por exemplo, se o cache estiver armazenando dados de um usuário, e esses dados forem atualizados, o cache ficará desatualizado, e a aplicação pode acabar retornando dados incorretos.

Nesses casos, é necessário invalidar o cache quando os dados forem atualizados. Isso pode ser feito de diversas formas, como por exemplo:

Invalidação manual

A invalidação manual é quando o cache é invalidado manualmente, ou seja, quando o desenvolvedor decide que o cache deve ser invalidado. Isso pode ser feito de diversas formas, como por exemplo utilizando um comando no terminal, ou utilizando uma interface gráfica.

Invalidação automática por tempo

A invalidação automática por tempo é quando o cache é invalidado automaticamente após um determinado tempo. Isso pode ser feito atraves de um timestamp, ou seja, quando o cache for criado, é armazenado o timestamp de quando ele foi criado, e quando o cache for acessado, é verificado se o timestamp é maior do que o tempo de vida do cache, se for, o cache é invalidado.

Invalidação automática por evento

A invalidação automática por evento é quando o cache é invalidado automaticamente quando um determinado evento ocorre, como por exemplo quando um dado é atualizado ou inserido no banco de dados.

Dados que não são acessados com frequência

Se os dados que estão sendo armazenados em cache não são acessados com frequência, o cache pode acabar ocupando espaço desnecessário na memória, o que pode causar problemas na aplicação. Isso pode acontecer, por exemplo, quando o cache é armazenado em um banco de dados em memória, como o Redis, e o espaço de memória do servidor é limitado.

Dados que são muito grandes

Dados de tamanho elevado podem acabar pesando muito o cache, o que pode deixar sua aplicação lenta. Nesses casos, é necessário avaliar se realmente vale a pena armazenar esses dados em cache ou fazer uma tela de loading para que o usuário aguarde o carregamento desses dados.

Conclusão

Como foi visto, o cache é uma ótima forma de otimizar uma aplicação web, porém, é necessário ter cuidado ao utilizá-lo, pois se for mal utilizado, ele pode acabar piorando a performance da aplicação e até mesmo causando problemas de segurança.

Uma boa prática é utilizar um serviço de monitoramento de cache, como o RedisInsight, para monitorar o cache e verificar se ele está sendo utilizado corretamente.

Existem diversas ferramentas que podem ser utilizadas para monitorar sua aplicação, como por exemplo:

• New Relic
• Datadog
• Sentry
• Grafana

Espero que esse artigo tenha sido útil para você. Se tiver alguma dúvida ou sugestão, deixe um comentário abaixo.

/*
* Nome do arquivo: main.c
* Descrição: Programa principal
* Autor: Luiz Schons
* Data: 01/01/2020
* Versão: 1.0
* Licença: MIT
*/

Ou então, algum repositório no GitHub com um arquivo LICENSE ou LICENSE.md com um conteúdo parecido com este:

MIT License

Mas o que é uma licença de software? Para que serve? Por que devo me preocupar com isso?

Esse assunto é muito importante para qualquer desenvolvedor de software, seja ele um desenvolvedor profissional ou um estudante. Neste artigo, vamos entender o que é uma licença de software, para que serve e quais são as principais licenças de software livre.

O que é uma licença de software?

Uma licença de software é um contrato entre o autor de um software e o usuário do software. Esse contrato define quais são os direitos e deveres do autor e do usuário do software.

O autor do software é a pessoa ou organização que criou o software. O usuário do software é a pessoa ou organização que utiliza o software.

Quando usamos o termo “utilizar o software”, estamos nos referindo a qualquer atividade que envolva o software, como executar o software, estudar o código fonte do software, modificar o código fonte do software, distribuir cópias do software, etc.

Normalmente uma licença de software é um documento de texto que contém os termos do contrato. Esse documento pode estar no próprio código fonte do software, em um arquivo separado ou em um arquivo chamado LICENSE ou LICENSE.md na raiz do repositório do software.

Quais são os tipos de licença de software?

Existem vários tipos de licença de software, hoje eu vou comentar sobre alguns tipos, mas não vou entrar em detalhes sobre cada um deles. Se você quiser saber mais sobre cada tipo de licença, recomendo que você leia o artigo Licenças de Software Livre no site da Free Software Foundation.

GNU General Public License (GPL)

A GNU General Public License é uma licença de software livre criada pela Free Software Foundation. Essa licença permite que o usuário do software execute, estude, modifique e distribua cópias do software, mas exige que o software e qualquer trabalho derivado do software seja distribuído sob os termos da GNU GPL e os direitos autorais do software sejam atribuídos ao autor original do software.

GNU Lesser General Public License (LGPL)

A GNU Lesser General Public License é uma licença de software livre criada pela Free Software Foundation. Essa licença esta no meio termo entre as licenças permissivas e as licenças copyleft. A principal diferença entre a GNU LGPL e a GNU GPL é que a GNU LGPL permite que o usuário do software utilize o software em um software proprietário, enquanto a GNU GPL não permite. Os trabalhos derivados do software devem estar disponíveis em bibliotecas.

BSD

A licença BSD é uma licença de software livre criada pela Universidade da Califórnia. Essa licença tem poucas restrições, ela permite que o usuário do software execute, estude e modifique o software, porém informe o nome de quem realizou a contribuição.

Apache License 2.0

A licença Apache License 2.0 é uma licença de software livre criada pela Apache Software Foundation. Essa licença permite ser usada em qualquer projeto, mas tem que observar as condições impostas nos termos descritos na licença. Permite a distribuição do software, modificações, sublicenciamento e uso comercial, porém deve-se informar termos de responsabilidade e avisos de direitos autorais.

MIT

A licença MIT é uma licença de software livre criada pelo Massachusetts Institute of Technology. Essa licença permite que o usuário do software execute, estude, modifique e distribua cópias do software. Nessa licença não é necessário que o software e qualquer trabalho derivado do software seja distribuído sob os termos da licença MIT.

Conclusão

Neste artigo, vimos o que é uma licença de software, para que serve e quais são os tipos de licença de software. Se você quiser saber mais sobre licenças de software, recomendo que você leia o artigo Licenças de Software Livre no site da Free Software Foundation.

Referências

• Licenças de Software Livre
• GNU General Public License
• GNU Lesser General Public License
• BSD
• Apache License 2.0
• MIT

O famoso CRUD (Create, Read, Update, Delete) é um dos padrões mais utilizados em aplicações web, porém, em alguns casos, o Delete não é tão simples assim.

Temos casos onde o usuário não pode excluir um registro, mas ele pode desativá-lo, ou seja, o registro não será mais exibido, mas ele ainda existe no banco de dados.

Por que não excluir?

Existem vários motivos para não excluir um registro, por exemplo, imagine que você tem um sistema de vendas e um cliente que já comprou um produto não pode ser excluído, pois, se ele for excluído, a venda ficará sem um cliente.

Ou imagine que você tem um sistema de controle de estoque e um produto que já foi vendido não pode ser excluído, pois, se ele for excluído, a venda ficará sem um produto.

Existem vários outros motivos para não excluir um registro, mas o que importa é que, em alguns casos, o registro não pode ser excluído.

O que é Soft Delete?

Soft Delete é uma técnica que consiste em não excluir um registro, mas sim desativá-lo, ou seja, o registro não será mais exibido, mas ele ainda existe no banco de dados.

Seria como se o registro fosse marcado como excluído, mas não fosse excluído de fato.

De que forma o Soft Delete é feito?

Existem várias formas de fazer o Soft Delete, mas a mais comum é adicionar um campo na tabela que será desativada, por exemplo, um campo chamado status que pode ter os valores ativo ou inativo, sendo que o valor inativo indica que o registro foi desativado.

Você também pode adicionar um campo chamado deleted_at que armazena a data e hora em que o registro foi desativado, sendo que, se o campo deleted_at estiver vazio, o registro está ativo, caso contrário, o registro está inativo.

Exemplo

Vamos supor que você tem uma tabela chamada clientes e você quer desativar um cliente, para isso, você pode adicionar um campo chamado status que pode ter os valores ativo ou inativo, sendo que o valor inativo indica que o registro foi desativado.

ALTER TABLE clientes ADD COLUMN status VARCHAR(7) NOT NULL DEFAULT 'ativo';

Agora, para desativar um cliente, basta alterar o valor do campo status para inativo.

UPDATE clientes SET status \= 'inativo' WHERE id \= 1;

Para verificar se um cliente está ativo ou inativo, basta verificar o valor do campo status.

SELECT * FROM clientes WHERE status \= 'ativo';

Mas todos concordam que isso é muito trabalhoso, pois, para cada tabela que você quiser desativar um registro, você terá que adicionar um campo chamado status e alterar o código para verificar o valor desse campo.

Dessa forma, os frameworks de desenvolvimento web criaram uma forma de fazer o Soft Delete de forma automática, ou seja, você não precisa adicionar um campo chamado status em cada tabela, pois o framework faz isso para você.

Como cada framework tem uma forma diferente de fazer o Soft Delete, vamos ver como é feito no Laravel, pois é o framework que eu mais utilizo.

Soft Delete no Laravel

O Laravel utiliza o campo deleted_at para armazenar a data e hora em que o registro foi desativado, sendo que, se o campo deleted_at estiver vazio, o registro está ativo, caso contrário, o registro está inativo.

Tudo começa com a criação da tabela, onde você deve adicionar o campo deleted_at na tabela que será desativada.

Aqui vamos criar uma tabela no banco de dados usando o Artisan do Laravel.

php artisan make:migration create_clientes_table

Agora vamos abrir o arquivo de migração que foi criado e adicionar o campo deleted_at na tabela.

Schema::create('clientes', function (Blueprint $table) {
$table->id();
$table->string('nome');
$table->string('email');
$table->string('telefone');
$table->timestamps();
$table->softDeletes();
});

Só vou dar uma explicação rápida sobre o código acima, pois não é o foco do artigo.

• O método id() cria um campo chamado id que é a chave primária da tabela.
• O método string() cria um campo do tipo VARCHAR.
• O método timestamps() cria dois campos chamados created_at e updated_at que armazenam a data e hora em que o registro foi criado e atualizado.
• O método softDeletes() cria um campo chamado deleted_at que armazena a data e hora em que o registro foi desativado.

Após adicionar o campo deleted_at na tabela, você deve executar a migração para criar a tabela no banco de dados.

php artisan migrate

Agora que a tabela foi criada, vamos criar um Model para ela.

php artisan make:model Cliente

Agora vamos abrir o arquivo do Model e adicionar a trait SoftDeletes.

O que é uma trait?

Uma trait é um recurso do PHP que permite que você adicione métodos em uma classe sem precisar herdar essa classe. Ou seja, você pode adicionar métodos em uma classe sem precisar herdar essa classe.

use Illuminate\Database\Eloquent\Model;

class Cliente extends Model
{
use SoftDeletes;
use HasFactory;

protected $fillable = [
'nome',
'email',
'telefone',
];

}

Só vou dar uma explicação rápida sobre o código acima, pois não é todo mundo que conhece o Laravel.

• O método use SoftDeletes adiciona a trait SoftDeletes no Model.
• O método use HasFactory adiciona a trait HasFactory no Model, isso é necessário para usar o recurso de Factory do Laravel.
• O método protected $fillable indica quais campos podem ser preenchidos em massa, ou seja, quais campos podem ser preenchidos usando o método create().

Agora que o Model foi criado, vamos criar um Controller para ele.

php artisan make:controller ClienteController --resource

O parâmetro --resource indica que o Controller será um Resource Controller, ou seja, um Controller que possui os métodos index, create, store, show, edit, update e destroy.

Agora vamos abrir o arquivo do Controller e adicionar o Model.

// ...

public function destroy(Cliente $cliente)
{
// ...
$cliente->delete();
// ...
}

// ...

O código acima é o método destroy() responsável por desativar um registro, ou seja, o código acima desativa um cliente.

Mas como o Laravel sabe que o registro foi desativado?

O Laravel sabe que o registro foi desativado porque o Model Cliente utiliza a trait SoftDeletes, ou seja, o Laravel sabe que o Model Cliente possui um campo chamado deleted_at que armazena a data e hora em que o registro foi desativado.

Se nós não tivéssemos utilizado a trait SoftDeletes, o Laravel não saberia que o Model Cliente possui um campo chamado deleted_at que armazena a data e hora em que o registro foi desativado, dessa forma, ao executar o método delete(), o Laravel iria excluir o registro.

Agora que o registro foi desativado, vamos verificar se ele está ativo ou inativo.

// ...

public function index()
{
// ...
$clientes = Cliente::all();
// ...
}

// ...

O código acima é o método index() responsável por exibir todos os registros, ou seja, o código acima exibe todos os clientes.

Mas como o Laravel sabe que o registro está desativado?

O Laravel sabe que o registro está desativado porque o Model Cliente utiliza a trait SoftDeletes, ou seja, o Laravel sabe que estamos utilizando o recurso de Soft Delete, dessa forma, ao executar o método all(), o Laravel não exibe os registros que estão desativados.

Se nós não tivéssemos utilizado a trait SoftDeletes, o Laravel não saberia que estamos utilizando o recurso de Soft Delete, dessa forma, ao executar o método all(), o Laravel exibiria todos os registros, inclusive os registros que estão desativados.

Conclusão

O Soft Delete é uma técnica que consiste em não excluir um registro, mas sim desativá-lo, ou seja, o registro não será mais exibido, mas ele ainda existe no banco de dados.

O Soft Delete é muito utilizado em sistemas que possuem um sistema de lixeira, ou seja, um sistema que armazena os registros desativados.

Durante o desenvolvimento de um sistema, você deve analisar se o registro pode ser excluído ou não, pois, se o registro não pode ser excluído, você deve utilizar essa técnica.

Lembre-se que o Soft Delete não é uma regra, ou seja, você não precisa utilizar essa técnica em todos os sistemas que você desenvolver, você deve analisar se o registro pode ser excluído ou não.

O artigo é só uma introdução ao Soft Delete, ou seja, o artigo não aborda todos os detalhes, porém, o artigo aborda os detalhes mais básicos e importantes.

Hoje em dia, o MVC é um dos padrões mais utilizados para o desenvolvimento de aplicações web em diversas linguagens de programação, incluindo o PHP.

Agora vamos entender melhor cada uma das partes do MVC.

Model

O Model é a parte da aplicação que representa a camada de dados, ou seja, a representação dos dados que são manipulados pela aplicação.

É literalmente um modelo da aplicação, que pode ser representado por uma classe, por exemplo.

Seguindo o exemplo de um sistema de cadastro de clientes, o Model seria a representação dos dados do cliente, como nome, e-mail, telefone etc.

Segue o exemplo de um Model de cliente em Laravel:

<?php
namespace App\Models;
use Illuminate\Database\Eloquent\Factories\HasFactory;
use Illuminate\Database\Eloquent\Model;
class Cliente extends Model
{
use HasFactory;
protected $fillable = [
'nome',
'email',
'telefone',
];
}

Dentro do Model, podemos definir regras de negócio, como funções para validar os dados, por exemplo.

public function adicionar($dados) {
return $this->create($dados);
}

public function atualizar($dados) {
return $this->update($dados);
}

public function excluir() {
return $this->delete();
}

public function buscar($id) {
return $this->find($id);
}

public function listar() {
return $this->all();
}

Lembre-se que esse código é apenas um exemplo didático, e que você pode implementar as regras de negócio da forma que achar melhor.

Controller

Pronto, já temos nosso modelo!

Como usamos ele agora? Com o Controller.

O Controller é literalmente o controlador da aplicação, que recebe as requisições do usuário e as manipula, retornando uma resposta.

No nosso exemplo, o Controller seria responsável por receber as requisições do usuário, como por exemplo: salvar um novo cliente, e manipular os dados, como por exemplo, salvar o cliente no banco de dados.

Segue o exemplo de um Controller de cliente em Laravel:

[...]
class ClienteController extends Controller
{
public function adicionar(Request $request) {
$cliente = new Cliente();
$cliente->adicionar($request->all());
return response()->json(['mensagem' => 'Cliente adicionado com sucesso!']);
}

public function atualizar(Request $request, $id) {
$cliente = Cliente::find($id);
$cliente->atualizar($request->all());
return response()->json(['mensagem' => 'Cliente atualizado com sucesso!']);
}

public function excluir($id) {
$cliente = Cliente::find($id);
$cliente->excluir();
return response()->json(['mensagem' => 'Cliente excluído com sucesso!']);
}

public function buscar($id) {
$cliente = Cliente::find($id);
return response()->json($cliente);
}

public function listar() {
$clientes = Cliente::listar();
return response()->json($clientes);
}
}

O Controller conhece o Model e pode manipular os dados através dele, mas também conhece a View e pode retornar uma resposta para o usuário através dela.

Dessa forma, o Controller é o intermediário entre o Model e a View.

View

A View é a parte da aplicação que representa a camada de apresentação, ou seja, a representação da interface gráfica da aplicação.

É literalmente a interface gráfica da aplicação, que pode ser representada por um arquivo HTML, por exemplo.

Seguindo o exemplo de um sistema de cadastro de clientes, a View seria a representação da interface gráfica do sistema como formulários, botões, tabelas etc.

Segue o exemplo de uma View de cliente em Laravel utilizando o Blade:

<!DOCTYPE html>

Clientes

Estou usando o livro para aprender sobre algoritmos e estruturas de dados, e escrever sobre o que estou aprendendo, pois acredito que assim eu consiga fixar melhor o conteúdo.

Capítulo 1 — Ordenação por Seleção

Arrays e Listas Encadeadas

Arrays e listas encadeadas são estruturas de dados que armazenam uma coleção de itens. A diferença entre elas é que os arrays são armazenados em blocos de memória contíguos, enquanto as listas encadeadas são armazenadas em blocos de memória não contíguos.

Nesse capítulo do livro, é ensinado a construir um algoritmo de ordenação, pois muitos algoritmos de busca e outros algoritmos dependem de uma lista ordenada para funcionar, como, por exemplo, o algoritmo de pesquisa binária.

Como funciona a memória?

A memória é um conjunto de células de memória, cada uma com um endereço único. Cada célula de memória pode armazenar um byte de informação. Um byte é um conjunto de 8 bits, e cada bit pode ser 0 ou 1.

Eu gosto do exemplo da biblioteca para entender como funciona a memória. Imagine que você está na biblioteca e quer pegar um livro. Você vai até a estante e pega o livro que está na posição 1. Depois você vai até a estante e pega o livro que está na posição 2. E assim por diante. Cada livro tem um número de identificação único, e você pode pegar o livro que você quiser, desde que você saiba o número de identificação dele.

A memória funciona da mesma forma. Cada célula de memória tem um endereço único, e você pode acessar qualquer célula de memória desde que você saiba o endereço dela.

Listas Encadeadas

Uma lista encadeada é uma estrutura de dados que armazena uma coleção de itens. Cada item da lista contém um campo de dados e um campo de referência. O campo de dados armazena o valor do item, e o campo de referência armazena o endereço da próxima célula de memória.

Referência: https://saulo.arisa.com.br/wiki/index.php/Listas_Encadeadas_Simples

Dessa forma, a lista encadeada é armazenada em blocos de memória não contíguos. O primeiro item da lista é armazenado em uma célula de memória, e o campo de referência desse item aponta para o endereço da próxima célula de memória. A próxima célula de memória armazena o segundo item da lista, e o campo de referência desse item aponta para o endereço da próxima célula de memória. E assim por diante.

Você pode acessar qualquer item da lista encadeada desde que você saiba o endereço do item que você quer acessar.

Arrays

Um array é uma estrutura de dados que armazena uma coleção de itens. Cada item do array é armazenado em uma célula de memória, e cada célula de memória tem um endereço único.

Referência: https://www.geeksforgeeks.org/array-data-structure/

Já que cada célula de memória tem um endereço único, você pode acessar qualquer item do array desde que você saiba o endereço do item que você quer acessar.

No entanto, os arrays são armazenados em blocos de memória contíguos. Isso significa que você não pode adicionar um novo item no meio do array, pois você precisaria mover todos os itens depois do item que você quer adicionar para uma nova posição na memória.

Desempenho

O desempenho de um algoritmo é medida em termos de tempo e espaço. O tempo é medido em termos de operações básicas, e o espaço é medido em termos de memória.

Caso você não saiba o que é Notação Big O, eu recomendo que você leia o artigo Introdução a algoritmos — Notação Big O.

O tempo de execução de um algoritmo é medido em termos de operações básicas. Uma operação básica é uma operação que leva o mesmo tempo para ser executada, independentemente do tamanho da entrada.

No caso de um array, a operação básica é a leitura de um item. No caso de uma lista encadeada, a operação básica é a leitura de um item e a leitura do campo de referência. Dessa forma, a operação básica de uma lista encadeada é mais complexa que a operação básica de um array, pois são necessárias duas leituras para acessar um item.

Por outro lado, a operação de adicionar ou remover um item de um array é mais complexa que a operação de adicionar ou remover um item de uma lista encadeada, pois é necessário mover todos os itens depois do item que você quer adicionar ou remover.

Recapitulando

• Arrays e listas encadeadas são estruturas de dados que armazenam uma coleção de itens.
• Os arrays são armazenados em blocos de memória contíguos, enquanto as listas encadeadas são armazenadas em blocos de memória não contíguos.
• Arrays possuem um tamanho fixo, enquanto listas encadeadas não possuem um tamanho fixo.
• Cada célula de memória tem um endereço único, e você pode acessar qualquer célula de memória desde que você saiba o endereço dela.
• A desempenho de um algoritmo é medida em termos de tempo e espaço. O tempo é medido em termos de operações básicas, e o espaço é medido em termos de memória.
• A operação básica de uma lista encadeada é mais complexa que a operação básica de um array, pois são necessárias duas leituras para acessar um item.
• A operação de adicionar ou remover um item de um array é mais complexa que a operação de adicionar ou remover um item de uma lista encadeada, pois é necessário mover todos os itens depois do item que você quer adicionar ou remover.

Finalização

Essa foi uma pequena documentação dos meus estudos, espero que possa ajudar mais pessoas.
Qualquer dúvida, correção ou sugestão pode deixar nos comentários.