Forem: slns

🦀 Rust's Type System: Forte, estático e à prova de erros/Strong, Static, and Built for Safety

slns — Mon, 21 Apr 2025 12:00:00 +0000

Se Ownership, Borrowing e Lifetimes são os pilares da segurança em Rust, então o sistema de tipos forte e estático é o alicerce que sustenta a robustez e a eficiência do código.

O que é o sistema de tipos de Rust?

Rust possui um sistema de tipos forte e estático, o que significa que os tipos de dados são verificados em tempo de compilação e não podem ser alterados durante a execução. Isso garante que erros de tipo sejam detectados cedo, antes mesmo de o programa ser executado.

fn main() {
    let numero: i32 = 10; // Tipo explícito: i32 (inteiro de 32 bits)
    let texto: &str = "Rust"; // Tipo explícito: &str (string imutável)

    // Erro: não é possível somar um inteiro e uma string
    // let resultado = numero + texto; // O compilador impede isto
}

Como funciona?

Tipos explícitos: Em Rust, os tipos podem ser declarados explicitamente, mas muitas vezes o compilador pode inferir os tipos automaticamente.
Verificação em tempo de compilação: O compilador verifica se as operações entre tipos são válidas, evitando erros como somar um número com uma string.
Sem conversões implícitas: Rust não permite conversões automáticas entre tipos incompatíveis. Se precisar converter um tipo para outro, deve ser feito de forma explícita.

fn main() {
    let numero: i32 = 10;
    let outro_numero: f64 = 5.5; // Tipo explícito: f64 (número de ponto flutuante)

    // Conversão explícita
    let soma = numero as f64 + outro_numero; // 'as' é usado para conversão
    println!("Soma: {}", soma);
}

O que não se pode fazer?

Não é possível ignorar os tipos ou forçar conversões inválidas. O compilador de Rust é rigoroso e impede operações que não fazem sentido, como somar um número com uma string ou converter tipos incompatíveis sem uma conversão explícita.

fn main() {
    let numero: i32 = 10;
    let texto: &str = "Rust";

    // Erro: tipos incompatíveis
    // let resultado = numero + texto; // O compilador impede isto
}

Porque é que isto é importante?

O sistema de tipos forte e estático permite:

Detectar erros cedo, durante a compilação, em vez de em tempo de execução
Código mais seguro e previsível, sem surpresas causadas por conversões implícitas
Melhor desempenho, pois o compilador pode otimizar o código com base nos tipos conhecidos

Rust obriga a pensar nos tipos de dados desde o início — e embora pareça exigente, isso resulta em código mais robusto, eficiente e livre de erros.

If Ownership, Borrowing, and Lifetimes are the pillars of safety in Rust, then the strong and static type system is the foundation that supports the robustness and efficiency of the code.

What is Rust's type system?

Rust has a strong and static type system, which means that data types are checked at compile time and cannot be changed during execution. This ensures that type errors are detected early, before the program is even run.

fn main() {
    let numero: i32 = 10; // Explicit type: i32 (32-bit integer)
    let texto: &str = "Rust"; // Explicit type: &str (immutable string)

    // Error: cannot add an integer and a string
    // let resultado = numero + texto; // The compiler prevents this
}

How does it work?

Explicit types: In Rust, types can be declared explicitly, but often the compiler can infer types automatically.
Compile-time verification: The compiler checks if operations between types are valid, avoiding errors like adding a number to a string.
No implicit conversions: Rust does not allow automatic conversions between incompatible types. If you need to convert one type to another, it must be done explicitly.

fn main() {
    let numero: i32 = 10;
    let outro_numero: f64 = 5.5; // Explicit type: f64 (floating-point number)

    // Explicit conversion
    let soma = numero as f64 + outro_numero; // 'as' is used for conversion
    println!("Soma: {}", soma);
}

What can't you do?

You cannot ignore types or force invalid conversions. Rust's compiler is strict and prevents operations that don't make sense, such as adding a number to a string or converting incompatible types without an explicit conversion.

fn main() {
    let numero: i32 = 10;
    let texto: &str = "Rust";

    // Error: incompatible types
    // let resultado = numero + texto; // The compiler prevents this
}

Why is this important?

The strong and static type system allows:

Detecting errors early, during compilation, rather than at runtime
Safer and more predictable code, without surprises caused by implicit conversions
Better performance, as the compiler can optimize the code based on known types

Rust forces you to think about data types from the start — and although it may seem demanding, this results in more robust, efficient, and error-free code.

🦀 Lifetimes - Rust: Garante que a memória vive o tempo certo!/Make Sure Memory Lives Just Long Enough!

slns — Sun, 20 Apr 2025 12:00:00 +0000

Se Ownership é o coração de Rust e Borrowing é o cérebro, então Lifetime é o sistema nervoso que garante que tudo funcione em harmonia.

O que é Lifetime?

Em Rust, o tempo de vida (lifetime) é uma forma de garantir que as referências sejam válidas durante todo o período em que são usadas. Ele assegura que uma referência nunca aponta para um valor que já foi destruído, evitando erros como acessos a memória inválida.

fn main() {
    let nome = String::from("Rust");
    // 'nome' é válido aqui
    {
        let saudacao = &nome; // 'saudacao' empresta 'nome'
        println!("{}", saudacao);
        // 'saudacao' é válido apenas dentro deste bloco
    }
    // 'saudacao' não é mais válido aqui, mas 'nome' ainda é
}

Como funciona?

O compilador de Rust analisa o código para garantir que as referências não sobrevivam aos valores aos quais estão associadas. Isso é feito através de anotações de tempo de vida, que explicitam as relações entre referências.

Vamos analisar um exemplo mais detalhado:

fn funcao<'a>(x: &'a i32, y: &'a i32) -> &'a i32 {
    x // Retorna uma referência com o mesmo tempo de vida dos parâmetros
}

Explicação detalhada:

Definição da função com lifetime

fn funcao<'a>(...)

Parâmetros da função

x: &'a i32, y: &'a i32

Tipo de retorno da função

-> &'a i32

Corpo da função

x // Retorna uma referência com o mesmo tempo de vida dos parâmetros

O que não se pode fazer?

Não se pode retornar uma referência que vive mais tempo do que o valor original. Isso evita que o programa acesse memória que já foi libertada.

fn erro<'a>() -> &'a i32 {
    let x = 10; // 'x' é criado aqui
    &x // Erro! 'x' é destruído no final da função, mas a referência tenta viver mais tempo
}

Porque é que isto é importante?

O sistema de Lifetime permite:

Garantir a segurança das referências sem necessidade de garbage collection
Evitar bugs como acessos a memória inválida ou referências pendentes
Código mais robusto e previsível

Rust obriga a pensar quanto tempo os dados são válidos — e embora pareça complexo no início, dá muito mais confiança e controle sobre o comportamento do programa.

If Ownership is the heart of Rust and Borrowing is the brain, then Lifetime is the nervous system that ensures everything works in harmony.

What is Lifetime?

In Rust, the lifetime is a way to ensure that references are valid throughout the period they are used. It ensures that a reference never points to a value that has already been destroyed, avoiding errors like invalid memory access.

fn main() {
    let nome = String::from("Rust");
    // 'nome' is valid here
    {
        let saudacao = &nome; // 'saudacao' borrows 'nome'
        println!("{}", saudacao);
        // 'saudacao' is valid only within this block
    }
    // 'saudacao' is no longer valid here, but 'nome' still is
}

How does it work?

The Rust compiler analyzes the code to ensure that references do not outlive the values they are associated with. This is done through lifetime annotations, which explicitly define the relationships between references.

Let's analyze a more detailed example:

fn funcao<'a>(x: &'a i32, y: &'a i32) -> &'a i32 {
x // Returns a reference with the same lifetime as the parameters
}

Detailed explanation:

Function definition with lifetime

fn funcao<'a>(...)

Function parameters

x: &'a i32, y: &'a i32

Function return type

-> &'a i32

Function body

x // Returns a reference with the same lifetime as the parameters

What can't you do?

You cannot return a reference that lives longer than the original value. This prevents the program from accessing memory that has already been freed.

fn erro<'a>() -> &'a i32 {
    let x = 10; // 'x' is created here
    &x // Error! 'x' is destroyed at the end of the function, but the reference tries to live longer
}

Why is this important?

The Lifetime system allows:

Ensuring the safety of references without the need for garbage collection
Avoiding bugs like invalid memory access or dangling references
More robust and predictable code

Rust forces you to think about how long the data is valid — and although it may seem complex at first, it gives you much more confidence and control over the behavior of the program.

🦀 Borrowing - Rust: Utilizar sem perder a posse./Access with Ownership Intact

slns — Sat, 19 Apr 2025 12:00:00 +0000

Se o Ownership é o coração de Rust, o Borrowing é o cérebro que permite trabalhar com dados sem perder a segurança.

O que é Borrowing?

Em Rust, emprestar um valor significa usá-lo temporariamente sem tomar a sua posse. Isso permite que múltiplas partes do código acessem os mesmos dados, mas sem risco de acessos inválidos ou modificações inesperadas.

fn main() {
    let nome = String::from("Rust");
    // Empresta 'nome' para a função, sem transferir a posse
    saudacao(&nome);
    println!("Olá, {}", nome); // 'nome' ainda é válido aqui
}

fn saudacao(n: &String) {
    println!("Olá, {}!", n);
}

Tipos de Empréstimos

&T (Empréstimo Imutável): Permite ler o valor, mas não modificá-lo.
&mut T (Empréstimo Mutável): Permite ler e modificar o valor, mas só pode existir um empréstimo mutável por vez.

fn main() {
    let mut valor = 10;
    // Empréstimo imutável
    imprime(&valor);
    // Empréstimo mutável
    modifica(&mut valor);
    println!("Valor final: {}", valor);
}

fn imprime(v: &i32) {
    println!("Valor: {}", v);
}

fn modifica(v: &mut i32) {
    *v += 5; // Modifica o valor original
}

O que não se pode fazer?

Não se pode ter empréstimos mutáveis e imutáveis ao mesmo tempo sobre o mesmo valor. Isso evita situações onde um valor é lido enquanto é modificado, o que poderia causar comportamentos imprevisíveis.

Porque é que isto é importante?

O sistema de Borrowing permite:

Acesso seguro a dados sem cópias desnecessárias
Controle total sobre quem pode ler ou modificar os dados
Código mais eficiente e livre de erros como data races

Rust obriga a pensar como os dados são usados — e embora pareça exigente no início, dá muito mais poder e confiança a longo prazo.

If Ownership is the heart of Rust, Borrowing is the brain that allows you to work with data without losing safety.

What is Borrowing?

In Rust, borrowing a value means using it temporarily without taking ownership of it. This allows multiple parts of the code to access the same data, but without the risk of invalid accesses or unexpected modifications.

fn main() {
    let nome = String::from("Rust");
    // Borrow 'nome' to the function without transferring ownership
    saudacao(&nome);
    println!("Hello, {}", nome); // 'nome' is still valid here
}

fn saudacao(n: &String) {
    println!("Hello, {}!", n);
}

Types of Borrowing

&T (Immutable Borrow): Allows reading the value but not modifying it.
&mut T (Mutable Borrow): Allows reading and modifying the value, but only one mutable borrow can exist at a time.

fn main() {
    let mut valor = 10;
    // Immutable borrow
    imprime(&valor);
    // Mutable borrow
    modifica(&mut valor);
    println!("Final value: {}", valor);
}

fn imprime(v: &i32) {
    println!("Value: {}", v);
}

fn modifica(v: &mut i32) {
    *v += 5; // Modifies the original value
}

What can't you do?

You cannot have mutable and immutable borrows at the same time over the same value. This prevents situations where a value is read while being modified, which could cause unpredictable behavior.

Why is this important?

The borrowing system allows:

Safe access to data without unnecessary copies
Full control over who can read or modify the data
More efficient and error-free code, avoiding issues like data races

Rust forces you to think about how data is used — and although it may seem demanding at first, it gives you much more power and confidence in the long run.

🦀 Rust Ownership: O segredo da programação!/The Coding Secret!

slns — Fri, 18 Apr 2025 11:22:48 +0000

Se tem uma coisa que define o Rust, é o conceito de Ownership (Propriedade).

Esse conceito é o que permite ao Rust ser seguro e rápido, sem precisar de garbage collector. Vamos entender como isto funciona?

O que é Ownership?

Em Rust, cada valor tem um dono: a variável que o criou (ou recebeu). Quando essa variável sai de escopo, o valor é automaticamente libertado da memória.

fn main() {
    let nome = String::from("Rust");
    println!("Olá, {}", nome);
} // <- 'nome' é destruído aqui, a memória é libertada

Transferência de Posse (Move)
Se atribuír uma variável a outra, o ownership é movido para a nova variável.

fn main() {
    let a = String::from("Ownership");
    let b = a; // 'a' perde a posse, 'b' agora é o dono

    // println!("{}", a); Erro! 'a' não é mais válida aqui
    println!("{}", b); // correto
}

Rust faz isso para garantir que nunca existam dois donos ao mesmo tempo — evitando bugs de memória.

O que não se pode fazer?

Não se pode usar uma variável depois de perder a posse do valor.
O compilador vai impedir a compilação se tentar fazê-lo. Pode parecer rígido no início, mas é isso que torna o código tão seguro.

Porque é que isto é importante?

O sistema de ownership permite:

Segurança de memória sem custos em tempo de execução
Desempenho comparável ao C/C++
Código livre de fugas de memória e acessos inválidos

Rust obriga a pensar quem é responsável pela memória — e embora pareça exigente no início, dá muito mais poder e confiança a longo prazo.

If there's one thing that defines Rust, it's the concept of Ownership.

This concept is what allows Rust to be safe and fast, without needing a garbage collector. Let's understand how this works?
What is Ownership?

In Rust, each value has an owner: the variable that created it (or received it). When this variable goes out of scope, the value is automatically freed from memory.

fn main() {
    let nome = String::from("Rust");
    println!("Hello, {}", nome);
} // <- 'nome' is destroyed here, memory is freed

Ownership Transfer (Move)

If you assign a variable to another, the ownership is moved to the new variable.

fn main() {
    let a = String::from("Ownership");
    let b = a; // 'a' loses ownership, 'b' is now the owner

    // println!("{}", a); Error! 'a' is no longer valid here
    println!("{}", b); // correct
}

Rust does this to ensure that there are never two owners at the same time — avoiding memory bugs.

What can't you do?

You can't use a variable after losing ownership of the value.
The compiler will prevent compilation if you try to do so. It might seem rigid at first, but it's what makes the code so safe.

Why is this important?

The ownership system allows:

Memory safety without runtime costs
Performance comparable to C/C++
Code free from memory leaks and invalid accesses

Rust forces you to think about who is responsible for the memory — and although it may seem demanding at first, it gives you much more power and confidence in the long run.

Code Testing: A Technical Guide to Testing Everything vs. Focusing on Services

slns — Fri, 15 Nov 2024 09:52:16 +0000

Testing is at the heart of software quality, but deciding what to test can be tricky. This article explores the pros and cons of testing every component versus focusing just on services, with detailed insights into each phase and component.

🧪 What Does Testing Everything Mean?

Testing everything involves covering all system components: enums, DTOs, controllers, services, repositories, traits, and utilities. This exhaustive approach brings safety but also complexity.

✅ Benefits

Maximum coverage: Each component is validated individually.
- Example: Testing the OrderStatus enum ensures invalid values like COMPLETED_WRONG are rejected.
Confidence in changes: Refactoring doesn’t break unrelated parts of the system.

❌ Drawbacks

High cost: Writing and maintaining all these tests takes significant time.
Test redundancy: Logic might be tested multiple times (e.g., in the model and service).

🛠️ What Does Testing Only Services Mean?

This approach assumes that services, which orchestrate other components, adequately represent system behavior.

✅ Benefits

Time-saving: Focuses on critical functionality.
- Example: A test for OrderService ensures the entire order creation process works correctly.
Essential coverage: Prioritizes the tests that matter most for end-users.

❌ Drawbacks

Hidden bugs: Issues in DTOs or validations may go unnoticed.
- Example: A mapping error in a DTO might not be caught until it’s too late.
Harder debugging: Finding the source of failures becomes more complex.

🧩 How to Test Each Component: A Technical Guide

1. Enums and Models

What to test? Behavior, validations, and data integrity.
Example: An OrderStatus enum should only accept values like PENDING, COMPLETED, and CANCELED.

2. DTOs and ViewModels

What to test? Data consistency during serialization/deserialization.
Example: An OrderDTO should correctly map JSON data into an expected model.

3. Controllers

What to test? Routing, HTTP responses, and basic validations.
Example: A GET /orders endpoint should return correctly formatted data with a 200 status.

4. Services and Repositories

What to test? Business rules and data persistence.
Example: The OrderService should calculate an order total correctly, including discounts.

5. Factories and Traits

What to test? Reusable functionality.
Example: A factory creating Order objects should populate default values as expected.

🏗️ The Testing Pyramid: Structuring Your Approach

A balanced approach follows the testing pyramid:

Unit Tests (Base): Cover isolated components like enums, DTOs, or small services.
Integration Tests (Middle): Ensure components interact properly.
End-to-End Tests (Top): Validate complete system behavior from the user’s perspective.

🎯 Conclusion: Striking the Ideal Balance

The decision to "test everything" or "only services" depends on your project’s complexity and goals. A pragmatic balance includes:

✅ Detailed tests for critical components.
🛠️ Service-focused tests for global functionality.
🎯 Avoiding redundancy and prioritizing quality over quantity.

Final Question:

How do you structure your tests? Share your thoughts in the comments! 🚀

Php Serialização

slns — Fri, 31 May 2024 19:16:58 +0000

Serialização e Desserialização em PHP

O que é Serialização?

Serialização é o processo de converter um objeto ou uma estrutura de dados em uma string. Esta string pode ser armazenada em um arquivo, transmitida pela rede ou armazenada em um banco de dados. A principal vantagem da serialização é que ela permite salvar o estado de um objeto de uma forma que possa ser facilmente recuperada mais tarde.

O que é Desserialização?

Desserialização é o processo inverso da serialização. Ela converte uma string serializada de volta em um objeto ou estrutura de dados original. Isso é útil para recuperar o estado de um objeto que foi salvo anteriormente.

Funções de Serialização em PHP

PHP fornece funções embutidas para serialização e desserialização:

`serialize()`

A função serialize() converte um valor PHP em uma string serializada.

$dados = array('nome' => 'João', 'idade' => 30);
$string_serializada = serialize($dados);
echo $string_serializada;

Saída:

a:2:{s:4:"nome";s:4:"João";s:5:"idade";i:30;}

`unserialize()`

A função unserialize() converte uma string serializada de volta ao seu valor original.

$string_serializada = 'a:2:{s:4:"nome";s:4:"João";s:5:"idade";i:30;}';
$dados = unserialize($string_serializada);
print_r($dados);

Saída:

Array
(
    [nome] => João
    [idade] => 30
)

Casos de Uso Comuns

Armazenamento de Sessões

A serialização é frequentemente usada para armazenar dados de sessão. Quando um utilizador faz login em um site, seus dados podem ser armazenados em uma sessão usando serialize(). Quando o utilizador retorna, os dados da sessão podem ser recuperados com unserialize().

Cache de Dados

Serialização é útil para cache de dados complexos. Por exemplo, uma resposta de API pode ser serializada e armazenada em cache para evitar fazer a mesma chamada repetidamente.

Persistência de Objetos

Objetos em PHP podem ser serializados e armazenados em um banco de dados. Quando necessário, eles podem ser recuperados e desserializados para restaurar seu estado original.

Considerações de Segurança

Ao utilizar unserialize(), é importante ter cuidado, especialmente com dados vindos de fontes não confiáveis. Um dado malicioso pode explorar vulnerabilidades no código e levar à execução de código arbitrário. Portanto, evite desserializar dados não confiáveis ou valide e sanitize adequadamente os dados antes de desserializar.

Exemplo Prático

Aqui está um exemplo completo de serialização e desserialização de um objeto.

Classe Exemplo

class Pessoa {
    public $nome;
    public $idade;

    public function __construct($nome, $idade) {
        $this->nome = $nome;
        $this->idade = $idade;
    }
}

// Criar um objeto
$pessoa = new Pessoa("Maria", 25);

// Serializar o objeto
$serializado = serialize($pessoa);
echo "Serializado: " . $serializado . "\n";

// Desserializar o objeto
$pessoa_desserializada = unserialize($serializado);
echo "Desserializado: " . $pessoa_desserializada->nome . ", " . $pessoa_desserializada->idade . "\n";

Saída

Serializado: O:6:"Pessoa":2:{s:4:"nome";s:5:"Maria";s:5:"idade";i:25;}
Desserializado: Maria, 25

Conclusão

A serialização e desserialização em PHP são técnicas poderosas para persistir e transmitir dados. Ao entender e utilizar corretamente serialize() e unserialize(), você pode facilmente salvar e restaurar o estado de dados complexos em suas aplicações PHP.

Php Closure

slns — Fri, 31 May 2024 19:02:38 +0000

Closure em PHP

Uma closure em PHP é uma função anônima que pode capturar variáveis do seu escopo circundante. Isso permite que a função acesse essas variáveis mesmo depois que o escopo externo tenha terminado. As closures são úteis para criar funções dinâmicas e encapsular comportamentos.

Exemplo Básico

<?php
$mensagem = "Olá, mundo!";

$minhaClosure = function() use ($mensagem) {
    echo $mensagem;
};

$minhaClosure(); // Saída: Olá, mundo!
?>

No exemplo acima:

A variável $mensagem é capturada pela closure através da cláusula use.
A closure é chamada mais tarde e ainda pode acessar $mensagem.

Usando Closure Dentro de uma Função

<?php
function criarSaudacao($nome) {
    $mensagem = "Olá, $nome!";

    // Definindo uma closure dentro da função
    $saudacao = function() use ($mensagem) {
        echo $mensagem;
    };

    // Retornando a closure
    return $saudacao;
}

$saudacaoParaJoao = criarSaudacao("João");
$saudacaoParaJoao(); // Saída: Olá, João!
?>

Neste exemplo, a closure é criada dentro da função criarSaudacao e captura a variável $mensagem do seu escopo.

Passando Variáveis por Referência

Por padrão, as variáveis são passadas por valor para a closure. Para passá-las por referência, use o operador &:

<?php
$contador = 10;

$minhaClosure = function() use (&$contador) {
    $contador++;
};

$minhaClosure();
echo $contador; // Saída: 11
?>

Aqui, a variável $contador é passada por referência, permitindo que a closure modifique seu valor original.

As closures em PHP são uma ferramenta poderosa para encapsular lógica e criar funções dinâmicas, mantendo o acesso a variáveis do escopo onde foram definidas.

Symfony 6 with docker

slns — Sat, 19 Nov 2022 16:53:42 +0000

In this project the intention is to create a project in symfony 6, with docker, mariadb, phpmyadmin.

To begin with, we will create a page structure similar to the image:

Make the folders, and some files:

mkdir symfony-6-docker && touch .env && touch .gitignore 
&& touch docker-compose.yml && touch README.md 
&& mkdir docker && cd docker && mkdir database 
&& mkdir logs && mkdir nginx && mkdir php-fpm 
&& cd database && mkdir data && touch Dockerfile  
&& touch init.sql && cd ../logs && mkdir nginx 
&& cd nginx && touch access.log && touch error.log 
&& touch .gitignore && cd ../../nginx && touch Dockerfile 
&& touch nginx.conf && mkdir conf.d && mkdir sites 
&& cd  conf.d && touch default.conf && cd ../sites 
&& touch default.conf && cd ../../php-fpm 
&& touch wait-for-it.sh && touch Dockerfile && cd ../..

After that, it is necessary to verify that we have everything necessary to create a symfony 6 project.
For this we run the command.

symfony check:requirements

When you get the same answer as the picture, it means that everything is fine.

Having everything ok, we create the project in the project root.

 symfony new symfony --version="6.1.*"

With your preferred IDE, open the project in the root, and copy the contents of the files.

docker-composer.yml

# docker-composer.yml
version: '3'

services:
  database:
    build:
      context: ./docker/database
    environment:
      - MYSQL_DATABASE=${DATABASE_NAME}
      - MYSQL_USER=${DATABASE_USER}
      - MYSQL_PASSWORD=${DATABASE_PASSWORD}
      - MYSQL_ROOT_PASSWORD=${DATABASE_ROOT_PASSWORD}
    ports:
      - "3309:3306"
    volumes:
      - ./database/init.sql:/docker-entrypoint-initdb.d/init.sql
      - ./docker/database/data:/var/lib/mysql

  phpmyadmin:
        depends_on:
            - database
        image: phpmyadmin
        links:
          - database
        restart: always
        ports:
            - 8080:80
        environment:
            PMA_HOST: database
            PMA_PORT: 3306
            PMA_ARBITRARY: 1

  php-fpm:
    build:
      context: ./docker/php-fpm
    depends_on:
      - database
    environment:
      - APP_ENV=${APP_ENV}
      - APP_SECRET=${APP_SECRET}
      - DATABASE_URL=mysql://${DATABASE_USER}:${DATABASE_PASSWORD}@database:3306/${DATABASE_NAME}?serverVersion=5.7
    volumes:
      - ./symfony:/var/www

  nginx:
    build:
      context: ./docker/nginx
    volumes:
      - ./symfony:/var/www
      - ./docker/nginx/nginx.conf:/etc/nginx/nginx.conf
      - ./docker/nginx/sites/:/etc/nginx/sites-available
      - ./docker/nginx/conf.d/:/etc/nginx/conf.d
      - ./docker/logs:/var/log
    depends_on:
      - php-fpm
    ports:
      - "80:80"
      - "443:443"

.env

DATABASE_NAME=symfony
DATABASE_USER=appuser
DATABASE_PASSWORD=apppassword
DATABASE_ROOT_PASSWORD=secret

APP_ENV=dev
APP_SECRET=change-to-your-secret-value

docker/database/Dockerfile

FROM mariadb:latest

CMD ["mysqld"]

EXPOSE 3306

docker/database/init.sql

CREATE DATABASE IF NOT EXISTS symfony;
USE symfony;

docker/nginx/Dockerfile

FROM nginx:alpine

WORKDIR /var/www

CMD ["nginx"]

EXPOSE 80 443

docker/nginx/nginx.conf

user  nginx;
worker_processes  4;
daemon off;

error_log  /var/log/nginx/error.log warn;
pid        /var/run/nginx.pid;


events {
    worker_connections  1024;
}


http {
    include       /etc/nginx/mime.types;
    default_type  application/octet-stream;

    access_log  /var/log/nginx/access.log;
    #access_log /dev/stdout;
    #error_log /dev/stderr;

    sendfile        on;
    #tcp_nopush     on;

    keepalive_timeout  65;

    #gzip  on;

    include /etc/nginx/conf.d/*.conf;
    include /etc/nginx/sites-available/*.conf;
}

docker/nginx/conf.d/default.conf

upstream php-upstream {
    server php-fpm:9000;
}

docker/nginx/sites/default.conf

server {

    listen 80 default_server;
    listen [::]:80 default_server ipv6only=on;

    server_name localhost;
    root /var/www/public;
    index index.php index.html index.htm;

    location / {
         try_files $uri $uri/ /index.php$is_args$args;
    }

    location ~ \.php$ {
        try_files $uri /index.php =404;
        fastcgi_pass php-upstream;
        fastcgi_index index.php;
        fastcgi_buffers 16 16k;
        fastcgi_buffer_size 32k;
        fastcgi_param SCRIPT_FILENAME $document_root$fastcgi_script_name;
        #fixes timeouts
        fastcgi_read_timeout 600;
        include fastcgi_params;
    }

    location ~ /\.ht {
        deny all;
    }

    location /.well-known/acme-challenge/ {
        root /var/www/letsencrypt/;
        log_not_found off;
    }
}

docker/php-fpm/Dockerfile

FROM php:fpm-alpine

COPY wait-for-it.sh /usr/bin/wait-for-it

RUN chmod +x /usr/bin/wait-for-it

RUN apk --update --no-cache add git

RUN apk add bash

RUN docker-php-ext-install pdo_mysql

COPY --from=composer /usr/bin/composer /usr/bin/composer

WORKDIR /var/www

CMD composer install ; wait-for-it database:3306 -- bin/console doctrine:migrations:migrate ;  php-fpm 

EXPOSE 9000

docker/php-fpm/wait-for-it.sh

#!/bin/sh

TIMEOUT=15
QUIET=0

echoerr() {
  if [ "$QUIET" -ne 1 ]; then printf "%s\n" "$*" 1>&2; fi
}

usage() {
  exitcode="$1"
  cat << USAGE >&2
Usage:
  $cmdname host:port [-t timeout] [-- command args]
  -q | --quiet                        Do not output any status messages
  -t TIMEOUT | --timeout=timeout      Timeout in seconds, zero for no timeout
  -- COMMAND ARGS                     Execute command with args after the test finishes
USAGE
  exit "$exitcode"
}

wait_for() {
  for i in `seq $TIMEOUT` ; do
    nc -z "$HOST" "$PORT" > /dev/null 2>&1

    result=$?
    if [ $result -eq 0 ] ; then
      if [ $# -gt 0 ] ; then
        exec "$@"
      fi
      exit 0
    fi
    sleep 1
  done
  echo "Operation timed out" >&2
  exit 1
}

while [ $# -gt 0 ]
do
  case "$1" in
    *:* )
    HOST=$(printf "%s\n" "$1"| cut -d : -f 1)
    PORT=$(printf "%s\n" "$1"| cut -d : -f 2)
    shift 1
    ;;
    -q | --quiet)
    QUIET=1
    shift 1
    ;;
    -t)
    TIMEOUT="$2"
    if [ "$TIMEOUT" = "" ]; then break; fi
    shift 2
    ;;
    --timeout=*)
    TIMEOUT="${1#*=}"
    shift 1
    ;;
    --)
    shift
    break
    ;;
    --help)
    usage 0
    ;;
    *)
    echoerr "Unknown argument: $1"
    usage 1
    ;;
  esac
done

if [ "$HOST" = "" -o "$PORT" = "" ]; then
  echoerr "Error: you need to provide a host and port to test."
  usage 2
fi

wait_for "$@"

After copying all the files, go to the root of the project, and run:
docker-compose up -d
Link to the project:
symfony project

Link to the phpmyadmin:
phpmyadmin

The project link on GitHub is:
symfony-6-docker

cheat sheet, Git Stash

slns — Wed, 04 Aug 2021 13:18:47 +0000

Git Stash

Short introduction:

Git stash allows you to save changes without interfering with commits.

For the list of all stashs:

  git stash list

To create a stash(no reference):

  git stash

To retrieve and delete the last stash:

  git stash pop

To retrieve and keep the last stash:

  git stash apply

To create a stash with identification:

  git stash save nome_do_stash
or
  git stash save 'nome do stash'

To retrieve and maintain a specific stash:

  git stash apply stash@{n}
or
  git stash apply n

To retrieve and delete a specific stash:

  git stash pop stash@{n}

To delete a specific stash

   git stash drop stash@{n}
or
   git stash drop n

cheat sheet, Git Stash

slns — Wed, 04 Aug 2021 13:10:47 +0000

Git Stash

Introdução resumida:

O git stash permite guardar alterações sem interferir com os commits.

Para obter a lista de todos os stashs:

  git stash list

Para criar um stash(sem referencia):

  git stash

Para recuperar e apagar o ultimo stash:

  git stash pop

Para recuperar e manter o ultimo stash:

  git stash apply

Para criar um stash com identificação:

  git stash save nome_do_stash
ou
  git stash save 'nome do stash'

Para recuperar e manter um stash especifico:

  git stash apply stash@{n}
ou
  git stash apply n

Para recuperar e apagar um stash especifico:

  git stash pop stash@{n}