DEV Community: Ranieri Valença

Criando e executando um projeto Laravel 12 com (quase) zero dependências usando Docker

Ranieri Valença — Fri, 28 Feb 2025 18:13:19 +0000

TL;DR

O objetivo deste artigo é criar e executar um projeto Laravel 12 sem instalar nenhuma dependência no sistema host. Para isso, criei um Dockerfile baseado na imagem oficial do PHP com o Composer e o Bun. Você pode ir direto para a seção Dockerfile se estiver com pressa.

Uma side quest é instalar a extensão do MongoDB para PHP. Você pode ir direto para a seção Expandindo o Dockerfile e dependências para ver como fiz isso.

Introdução

Como professor de Desenvolvimento Web, em geral tenho que lidar com muitos ambientes, linguagens e frameworks diferentes. Muitas vezes tenho que instalar binários, bibliotecas e dependências no sistema para poder rodar um simples "Hello World". Isso não só consome tempo, mas também pode causar conflitos entre diferentes versões da mesma biblioteca ou binário.

Como sou ~um pouco~ desorganizado, em geral eu esqueço de desinstalar essas dependências e binários depois de terminar meu trabalho. Isso deixa muito lixo no sistema, o que pode deixá-lo mais lento e, mais uma vez, gerar muitos conflitos.

Ontem me deparei com um novo desafio em um projeto de alguns estudantes: eles queriam criar um projeto Laravel 12 no laboratório da faculdade, mas não tinham permissão para instalar nada no sistema. Além disso, a versão do PHP instalada no laboratório estava desatualizada (para o Laravel 12) e seria trabalhoso atualizar. Para completar, eles queriam conectar o Laravel a um banco de dados MongoDB – que também não estava instalado.

Então, propus um desafio: criar um projeto Laravel 12 sem instalar nenhuma dependência. E agora estou compartilhando esse desafio com você — junto com a minha solução.

Neste artigo, apresentarei meu fluxo de trabalho para atingir esse objetivo. Vou compartilhar meus pensamentos e decisões, os problemas que enfrentei e como os resolvi. Até porque além de ser um desenvolvedor bem apaixonado pelo que faço, também sou professor, então tentarei explicar tudo de uma forma mais simples e leve. Espero que goste!

O processo

Depois de algumas considerações, a solução que encontrei foi usar o Docker para criar um contêiner com todas as dependências necessárias para rodar um projeto Laravel 12. Dessa forma, podemos criar um projeto Laravel dentro do contêiner e executá-lo sem instalar nada no sistema host, ou simplesmente usar o contêiner como um ambiente de desenvolvimento e (meio que) rodar o projeto no sistema host.

Claro, dava pra obter o mesmo resultado usando uma máquina virtual, mas o Docker é mais rápido e leve. Também (provavelmente) tinha como usar ambientes virtuais (virtual environments), mas eles seriam menos diretos e mais complexos. Além disso, ou eles não funcionariam no laboratório da faculdade ou os alunos iriam deixar o ambiente virtual rodando indefinidamente, criando problemas para outros alunos (às vezes menos experientes), o que iria criar mais dor de cabeça.

Voltando à ideia de usar o Docker, parece ser um pouco desafiador no início, porque os requisitos do Laravel 12 são: PHP, Composer, o Laravel Installer (um binário que hoje em dia eu normalmente evito instalar no sistema) e Node + NPM (ou Bun (?)). Há alguns outros requisitos que eles não mencionam, mas falaremos sobre isso mais tarde.

Sempre que preciso rodar algo em um contêiner Docker, eu procuro no Docker Hub oficial por uma imagem que já tenha as dependências de que preciso. Também prefiro usar imagens oficiais porque:

Eu confio mais nelas.
Elas geralmente estão mais atualizadas.

Para o desafio proposto e levando em conta minhas preferências pessoais, encontrei as seguintes imagens:

Cada uma delas tem uma imagem oficial no Docker Hub, mas não foram feitas para serem usadas juntas. Então, eu tenho que criar um Dockerfile personalizado para gerar um contêiner com todas as dependências necessárias. E agora eu tenho que decidir qual delas usar como base para facilitar o trabalho.

Atualmente, a imagem latest do Composer é baseada no Alpine Linux, que é muito minimalista e leve, mas exigiria que eu instalasse PHP e Node manualmente. Já as imagens do Node e do PHP são baseadas no Debian (que é minha zona de conforto). Então, decidi usar a imagem do PHP como base para meu Dockerfile.

Prova de conceito

Eu invejo aquelas pessoas que conseguem diretamente escrever um Dockerfile sem testar nada no mundo real — pessoas que realmente sabem o que estão fazendo e quais comandos e pacotes precisam. Eu não sou uma dessas pessoas. Então, antes de ir para o Dockerfile, decidi criar um contêiner com a imagem PHP e tentar instalar o Composer e o Bun manualmente.

docker run -it --rm php bash

Esse comando vai criar um contêiner com a imagem PHP e executar o comando bash dentro dele. O parâmetro --rm vai remover o contêiner assim que ele for encerrado. Assim, posso testar as coisas sem deixar lixo (contêiners parados) no meu sistema.

Composer

Beleza, agora estou dentro do contêiner. Vamos tentar instalar o Composer.

php -r "copy('https://getcomposer.org/installer', 'composer-setup.php');"
php composer-setup.php
php -r "unlink('composer-setup.php');"

Funcionou! Agora só falta um comando para mover o arquivo composer.phar para o diretório /usr/local/bin e torná-lo disponível globalmente (não no meu sistema, mas no contêiner).

mv composer.phar /usr/local/bin/composer

Bun

Ótimo. Agora, para aumentar um pouco o desafio, vamos tentar instalar o Bun — um gerenciador de pacotes alternativo ao Node.js. Não sei se vai funcionar, mas vamos tentar.

curl -fsSL https://bun.sh/install | bash

😒! O Bun precisa do unzip, que não está instalado no contêiner. Vamos instalar.

apt-get update && apt-get install -y unzip

Agora, de volta à instalação do Bun.

curl -fsSL https://bun.sh/install | bash

Funcionou! Só mais um comando que o Bun pediu para rodar, e está instalado.

source /root/.bashrc

Na verdade, ele já estava instalado, mas para que funcionasse na sessão atual do shell, eu tive que rodar esse comando para recarregar o arquivo .bashrc.

Agora vamos testar se tudo está funcionando até agora.

composer --version
bun --version

Lindo! 🎉 Agora podemos criar um projeto Laravel, conforme recomendado pela documentação oficial.

composer global require laravel/installer

Esse comando instalará o Laravel Installer globalmente, para que possamos executá-lo de qualquer lugar.

Ok, agora, o próximo passo:

laravel new example-app
# bash: laravel: command not found

Wat? Isso não estava no plano. Por que isso está acontecendo? Vamos tentar descobrir.

De acordo com a documentação do Composer, o comando composer global que acabei de rodar instala pacotes no diretório COMPOSER_HOME. Vamos verificar isso.

echo $COMPOSER_HOME

Ah, ótimo - não tem a variável de ambiente COMPOSER_HOME. Vamos voltar para a documentação do Composer e ver o que ela diz. Ah, certo, por padrão ela é ~/.composer. Vamos verificar.

ls -la ~/.composer

Bom, tem um diretório vendor lá, e ao verificá-lo (ls -la ~/.composer/vendor) eu vejo um diretório Laravel e um diretório bin dentro dele. Vamos dar uma olhada no diretório bin.

ls -la ~/.composer/vendor/bin

Hmm, lá está um arquivo executável chamado laravel. Vamos tentar rodá-lo.

~/.composer/vendor/bin/laravel  --version

Funcionou! Agora preciso adicionar o diretório ~/.composer/vendor/bin à variável de ambiente PATH.

export PATH=$PATH:/root/.composer/vendor/bin

Outra forma de acessar o executável laravel é pelo comando Composer exec.

composer global exec laravel -- --version

Agora posso (com sorte) criar um projeto Laravel.

laravel new my-app

O processo de criação de um projeto Laravel agora faz umas perguntas a mais do que antes (já faz mais de um ano desde o meu último projeto Laravel), mas (meio que) funcionou. No final do processo, ele perguntou se eu queria rodar npm install e npm run dev. Eu disse "sim", mas falhou porque optei por usar Bun e ele não tem o npm instalado.

O projeto Bun parece promissor (essa é a minha primeira vez usando), mas o Laravel ainda parece otimizado para Node.js e NPM. Vou tentar instalar as dependências usando Bun.

cd my-app
bun i # ou bun install

Bem, funcionou. Não tenho certeza se essa abordagem funcionará para todos os projetos Laravel. Mas, por enquanto, estou feliz com os resultados.

composer run dev

E... não. Parece que a versão 12 do Laravel está no meio de uma migração do método "antigo" com php artisan ... para os scripts do Composer (até porque dentro destes scripts ele ainda roda o php artisan) e, embora sugira Bun como uma alternativa ao Node.js+NPM, ainda usa scripts NPM. O último comando falhou porque ele tentou rodar npx ... e recebi um erro sh: 1: npx: not found. Que pena.

Agora tenho algumas opções aqui:

Instalar Node.js e npx neste contêiner.
Mudar o projeto Laravel para usar Bun em vez de NPM.
Descobrir qual é o substituto do Bun para npx e usá-lo.

Vou optar pela última. A documentação do Bun CLI apresenta bunx ou bun x como substituto do npx. Verificando a origem do bunx dentro do contêiner (which bunx) e listando (ls -la $(which bunx)), posso ver que é um symlink para o executável bun. Então, vamos tentar criar outro symlink para ele, chamado — você adivinhou — npx.

ln -s $(which bunx) /usr/local/bin/npx

Agora vamos tentar rodar o comando composer run dev novamente.

composer run dev

E funcionou! Bem, pelo menos o comando npx funcionou. Agora recebi uma exceção PHP pedindo pela extensão pcntl. Felizmente, escolhi a imagem do PHP como base — diretamente da visão geral dela (https://hub.docker.com/_/php) temos "Como instalar mais extensões PHP" (como eu queria que todas as imagens tivessem esse tipo de documentação). Vamos tentar instalar a extensão que falta.

docker-php-ext-install pcntl

E agora posso tentar novamente.

composer run dev

E funcionou! Agora eu tenho um projeto Laravel 12 rodando em um contêiner com zero dependências instaladas no meu sistema. Estou feliz com os resultados até agora. Também estou feliz com todos os passos que tomei para chegar até aqui. Agora, vamos para o próximo passo e criar um Dockerfile para automatizar todos esses passos.

O Dockerfile

Agora me sinto confiante o suficiente para criar um Dockerfile para automatizar todos esses passos. Vamos criar um arquivo chamado Dockerfile (touch Dockerfile se você estiver em um sistema Unix (Linux ou MacOS), ou type nul > Dockerfile se você estiver no Windows) e colar o seguinte conteúdo.

FROM php:latest

# Instalar unzip
RUN apt update && apt install -y unzip

# Instalar Composer de outra forma, mas com o mesmo resultado
RUN curl -sS https://getcomposer.org/installer | php -- --install-dir=/usr/local/bin --filename=composer

# Configurar as variáveis de ambiente
ENV HOME="/root"
ENV PATH="/root/.composer/vendor/bin:${PATH}:/root/.bun/bin"

# Instalar Bun
RUN curl -fsSL https://bun.sh/install | bash

# Criar alguns symlinks para o executável bun
RUN ln -s $(which bun) /usr/local/bin/npm
RUN ln -s $(which bunx) /usr/local/bin/npx

# Instalar o Laravel Installer
RUN composer global require laravel/installer

# Instalar a extensão pcntl
RUN docker-php-ext-install pcntl

Agora vamos construir a imagem.

docker build -t laravel12 .

Dá pra ver que eu adicionei mais uns comandos ao Dockerfile criando "aliases" para o npm e o npx (redirecinando para o bun e o bunx, respectivamente).

Este comando criará uma imagem chamada laravel12 baseada no Dockerfile que acabamos de criar. Neste ponto, o arquivo não é mais necessário, então, fique à vontade para excluí-lo.

Neste passo, acabamos de criar uma imagem no nosso daemon Docker local. Se você quiser compartilhar essa imagem com outros, pode enviá-la para um Docker registry. Mas esse é um assunto para outro momento. De qualquer forma, enviei essa imagem para minha conta no Docker Hub e ela está disponível para você usar.
docker pull ranierivalenca/laravel12

Testando

Com a imagem criada e registrada no daemon Docker local, agora podemos criar um contêiner com ela.

docker run -it --rm laravel12 bash

Se tudo correr bem, você deve estar dentro do contêiner. Agora podemos criar um projeto Laravel.

Criando um projeto Laravel

Ok, vamos dar uma pausa para recapitular o que fizemos até aqui. Criamos um Dockerfile que cria um contêiner com todas as dependências necessárias para rodar um projeto Laravel 12. Construímos a imagem e conseguimos criar um contêiner com ela. Agora, se criarmos um projeto Laravel dentro desse contêiner, todos os arquivos do projeto ficarão dentro do contêiner e serão perdidos quando o contêiner for interrompido. Para evitar isso, podemos criar um volume para armazenar os arquivos do projeto no sistema host.

docker run -it --rm -v $(pwd):/app laravel12 laravel new my-app

Dessa forma, estamos criando um volume que mapeia o diretório atual ($(pwd)) para o diretório /app dentro do contêiner. Assim, o diretório my-app será criado dentro do diretório atual no sistema host. Agora podemos rodar o projeto.

cd my-app
docker run -it --rm -v $(pwd):/app -w /app laravel12 composer run dev

Esse comando cria um contêiner com o diretório my-app (agora o diretório atual graças ao comando cd) montado no diretório /app dentro do contêiner. Ele também define o diretório de trabalho como /app (para não precisarmos digitar /app em cada comando ou rodar um comando cd).

Tadah! Está rodando. Mas ainda não podemos acessar o projeto no navegador porque não expusemos nenhuma porta. E, além disso, por padrão (pelo menos neste momento), o comando composer run dev inicia tanto o servidor PHP quanto o Vite (JS) vinculados ao 127.0.0.1 (localhost). Isso funciona quando estamos rodando o projeto diretamente no sistema host, mas não quando estamos rodando dentro de um contêiner. Mesmo se expusermos as portas, o aplicativo dentro do contêiner não responderá a solicitações vindas do systema host porque ele está vinculado ao localhost do contêiner.

Tudo isso pode parecer um pouco confuso, mas não se preocupe. Vamos resolver isso. Resumidamente, tudo que precisamos fazer é alterar o comando artisan serve para escutar em 0.0.0.0 e adicionar a opção --host ao comando npm run dev. A gente pode fazer isso apenas alterando o arquivo composer.json do projeto.

sed -i 's/artisan serve/artisan serve --host 0.0.0.0/g' composer.json
sed -i 's/run dev/run dev --host/g' composer.json

Se você estiver usando Windows, você pode instalar o Git Bash ou o WSL para rodar esses comandos. Se você estiver usando o MacOS, o comando sed -i espera um argumento para criar um backup do arquivo original. Se você não quiser criar um backup, adicione um argumento vazio, como sed -i ''. Claro que você também pode fazer essa edição manualmente usando um editor de texto.

Agora a gente pode rodar o projeto de novo, expondo as portas necessárias.

docker run -it --rm -v $(pwd):/app -w /app -p 8000:8000 -p 5173:5173 laravel12 composer run dev

Agora você pode acessar o projeto Laravel no navegador em http://localhost:8000.

Expandindo o Dockerfile e dependências

Como eu falei antes, este projeto específico requer uma conexão com o MongoDB. Então, temos que instalar a extensão mongodb para o PHP. Também vamos precisar ter o servidor de MongoDB rodando. Vamos por partes.

Adicionando a extensão PHP MongoDB

Para nossa sorte, a imagem do PHP que estamos usando vem com alguns scripts para ajudar a instalar extensões PHP. Vamos usar um desses scripts para instalar a extensão mongodb. Como antes, vamos criar um contêiner para testar a instalação manualmente.

docker run -it --rm laravel12 bash
# Dentre do contêiner
docker-php-ext-install mongodb

Epa. Não funcionou. A extensão mongodb não está disponível em /usr/src/php/ext, diretório do contêiner que vêm com algumas extensões pré-instaladas. Vamos tentar instalar a extensão manualmente. Vamos tentar com o PECL.

pecl install mongodb

O processo de instalação vai perguntar algumas coisas. Apenas vá apertando Enter para acetar os valores padrão. Você pode ler mais sobre as opções no site do PECL, no site do MongoDB ou no site do PHP.

Agora (depois de algum tempo - essa extensão é grande e o processo de instalação é lento), a extensão mongodb está instalada, mas não está habilitada. Vamos habilitá-la.

docker-php-ext-enable mongodb

E agora a extensão mongodb está habilitada. Vamos testar.

php -m | grep mongodb

Pronto. Podemos sair do contêiner e criar o Dockerfile para automatizar a instalação da extensão mongodb.

FROM laravel12

# Instalar a extensão mongodb
RUN pecl install mongodb && docker-php-ext-enable mongodb

Você pode notar que esse processo é bem simiar ao que usamos pra instalar a extensão pcntl antes. A principal diferença é que a extensão pcntl já está disponível no diretório /usr/src/php/ext e pode ser instalada com o comando docker-php-ext-install. Já a extensão mongodb não está disponível lá e tem que ser instalada com o PECL.

Usando esse novo Dockerfile, podemos construir uma nova imagem.

docker build -t laravel12:with-mongodb .
docker run -it --rm laravel12:with-mongodb php -m | grep mongodb

Usando esses conhecimentos, podemos expandir o Dockerfile para instalar qualquer extensão PHP que precisarmos, seja usando o docker-php-ext-install ou o PECL.

Se essa imagem for exatamente o que você precisa (ou seja, algo capaz de criar / executar um projeto em Laravel 12 com MongoDB), você pode encontrá-la no meu Docker Hub e usá-la.
docker pull ranierivalenca/laravel12:with-mongodb

Adicionando o servidor MongoDB

Para rodar o servidor MongoDB, podemos usar a imagem oficial do MongoDB. Vamos criar um contêiner com essa imagem.

docker run -d --name mongodb -p 27017:27017 --network-alias mongo mongo

Com esse comando, estamos criando um contêiner chamado mongodb com a imagem oficial do MongoDB. Estamos expondo a porta 27017 para o host (caso queiramos acessar o servidor MongoDB diretamente) e estamos adicionando um alias de rede mongo para o contêiner (para que possamos nos referir a ele pelo nome mongo em vez de pelo IP) dentro da rede padrão do Docker. Agora, podemos acessar o servidor MongoDB pelo nome mongo - lembre que o projeto Laravel vai rodar dentro de um contêiner e, por padrão, os contêineres podem se comunicar entre si pelo nome ou pelo IP (ambos atribuídos pelo Docker).

Conclusão

Eu espero que você tenha aproveitado essa jornada tanto quanto eu. Eu aprendi muito enquanto escrevia este artigo e espero que você também tenha aprendido algo. Se você tiver alguma dúvida, sugestão ou correção, fique à vontade para comentar.

Creating and running a Laravel 12 Project with (kinda) Zero Dependency using Docker

Ranieri Valença — Fri, 28 Feb 2025 16:29:22 +0000

TL;DR

The goal is to create and run a Laravel 12 project without installing any dependencies on the host system. To achieve this, I created a Dockerfile containing PHP, Composer and Bun. You can jump to the Dockerfile section to see the final result if you are in a hurry.

A side quest is to install the MongoDB PHP extension. You can jump to the Extending the Dockerfile and dependencies section to see how I did it.

Introduction

As a Web Development teacher, I have to deal with many different environments, languages and frameworks. Often I have to install a lot of binaries, libraries and dependencies system-wide to be able to run a simple "Hello World" program. This is not only time-consuming but also can lead to conflicts between different versions of the same library or binary.

Since I’m quite disorganized, I tend to forget to uninstall these dependencies and binaries after finishing my work. This leads to a lot of garbage in my system, which can slow down my computer and make it harder to find the right version of a library when I need it. Also, again, lots of conflicts.

Yesterday I faced a new challenge on a student's project: they wanted to create a Laravel 12 project on the college lab environment, but they didn't have the permissions to install anything on the system. Moreover, the PHP version installed on the lab was outdated (for Laravel 12 purposes) and they couldn't update it. And they wanted to connect Laravel with a MongoDB database - which wasn't installed.

So, I proposed a challenge: create a Laravel 12 project with zero installed dependencies. And now I'm sharing this challenge with you - with my solution.

In this article, I'll present you my workflow for achieving this goal. I'll share my thoughts and decisions, the problems I faced and how I solved them.
In addition to being a very passionate developer, I'm also a teacher, so I'll try to explain everything I did in a way that everyone can understand. I hope you enjoy it.

The process

After some consideration, the solution I found was to use Docker to create a container with all the dependencies needed to run a Laravel 12 project. This way, we can create a Laravel project inside the container and run it without installing anything on the host system. Or just use the container as a development environment and (kinda) run the project on the host system. This way, we can also avoid conflicts between different versions of the same library or binary.

Of course we could achieve the same result using a virtual machine, but Docker is faster and more lightweight. We could (probably) also use virtual environments, but they would be less straightforward and more complex. And they either wouldn’t work in the college lab environment or students would leave the virtual environment running indefinitely, leading to other (less experienced) students using and messing with it.

Back to the Docker approach, this can be a bit challenging at first, because Laravel 12's requirements are: PHP, Composer, the Laravel Installer (the kind of binary I usually avoid to install system-wide) and Node + NPM (or Bun (?)). There are some more requirements they don't mention, but we'll talk about them later.

Usually when I need to run something on a Docker container, I look at the official Docker Hub to find an image that already has the dependencies I need. I also have a personal preference for using official images, because I (1) trust them more and (2) they are usually more up-to-date.

For this challenge, considering my personal preferences, I found the following images:

Each of these has an official image on Docker Hub, but they are not meant to be used together. So, I had to create a custom Dockerfile to create a container with all the dependencies I needed. And now I have to decide which one will be the base image that will make work easier.

As for now, the latest image for Composer is based onAlpine Linux, that is very minimal and lightweight, but would require me to install PHP and Node manually. Node and PHP are both based on Debian (what makes me feel more comfortable). So, I decided to use the PHP image as the base image for my custom Dockerfile.

The proof of concept

I envy those who can jump straight into writing a Dockerfile without real-world testing — people who truly know what they’re doing and which commands and packages they need. I’m not one of them. So, before heading to the Dockerfile, I decided to create a container with the PHP image and try to install Composer and Bun on it.

docker run -it --rm php bash

This command will create a container with the PHP image and run the bash command inside it. The --rm flag will remove the container when it stops. This way, I can test things without leaving garbage on my system.

Composer

Okay, now I'm inside the container. Let's try to install Composer.

php -r "copy('https://getcomposer.org/installer', 'composer-setup.php');"
php composer-setup.php
php -r "unlink('composer-setup.php');"

It worked! Just one more command to move the composer.phar file to the /usr/local/bin directory and make it system-wide available (not on my system, but on the container).

mv composer.phar /usr/local/bin/composer

Bun

Nice. Now, for a bit of a challenge, let's try to install Bun - a Node.js version manager. I'm not sure if it will work, but let's try.

curl -fsSL https://bun.sh/install | bash

Oh crap! Bun needs unzip that isn't installed on the container. Let's install it.

apt-get update && apt-get install -y unzip

Back to the Bun installation.

curl -fsSL https://bun.sh/install | bash

It worked! One more command Bun asked me to run and it's installed.

source /root/.bashrc

In fact it was already "installed", but in order to get it working on my current shell session, I had to run this to reload the .bashrc file.

Now, let’s test if everything is working so far.

composer --version
bun --version

Beautiful! Let's create a Laravel project now as it is recommended by the official documentation.

composer global require laravel/installer

This command will install the Laravel Installer globally, so we can run it from anywhere.

Okay, next.

laravel new example-app
# bash: laravel: command not found

Wait, wat? This wasn't part of the plan. Why is this happening? Let's try to find out.

According to Composer documentation, the composer global command I have just run installs packages in the COMPOSER_HOME directory. Let's check it out.

echo $COMPOSER_HOME

Oh, great - there is no COMPOSER_HOME environment variable. Let's go back to the Composer documentation and see what it says. Oh, okay, by default it is ~/.composer. Let's check it out.

ls -la ~/.composer

Well, there is a vendor directory there, and checking it out (ls -la ~/.composer/vendor) I can see a Laravel directory and a bin directory inside it. Let me check the bin directory.

ls -la ~/.composer/vendor/bin

Hmm, there is a laravel executable file there. Let's try to run it.

~/.composer/vendor/bin/laravel  --version

It worked! Now I have to add the ~/.composer/vendor/bin directory to the PATH environment variable.

export PATH=$PATH:/root/.composer/vendor/bin

Another way to access the laravel executable is through the Composer exec command.

composer global exec laravel -- --version

Now I can (hopefully) create a Laravel project.

laravel new my-app

Laravel now asks me some more questions than before (more than a year since my last Laravel project), but it (kinda) worked. By the end of the process, it asked if I wanted to run npm install and npm run dev. I said yes, but it failed because I opted for Bun instead and it has no npm installed.

The Bun project looks promising (this is my first time using it), but Laravel still seems to be optimized for Node.js and NPM. Let me try installing dependencies using Bun instead.

cd my-app
bun i # or bun install

Well, it worked. I’m unsure if this approach will work for all Laravel projects. Still, I’m happy with the results so far.

composer run dev

Aaaanndd... no. It looks like Laravel 12 is transitioning from "old school laravel's" php artisan ... to Composer's scripts and while it suggests Bun as an option to Node.js+NPM, it still uses NPM scripts. The last command failed because it tried to run npx ... and I got a sh: 1: npx: not found error. So sad.

Now I have some options here:

install Node.js and npx on this container;
change the Laravel project to use Bun instead of NPM;
find what is the bun replacement for npx and use it.

I'll dig a bit more on the last option. The Bun CLI documentation presents bunx or bun x as a replacement for npx.Checking the bunx origin inside the container (which bunx) and listing it (ls -la $(which bunx)), I see that it's a symlink to the bun executable. So, let's try to create another symlink to it called - you guessed it - npx.

ln -s $(which bunx) /usr/local/bin/npx

Now let's try running the composer run dev command again.

composer run dev

And it worked! Well, at least the npx command did. Now I have a PHP RuntimeException asking me for the pcntl extension. Luckily I choose the PHP image as the base image - directly from its overview (https://hub.docker.com/_/php) we have "How to install more PHP extensions" (how I wish all images had this kind of documentation). Let's try to install the missing extension.

docker-php-ext-install pcntl

And now I can try again.

composer run dev

And it worked! I have a Laravel 12 project running on a container with zero installed dependencies. I'm happy with the results so far. I'm also happy with all steps I took to get here. Now, let's move on to the next step and create a Dockerfile to automate all these steps.

The Dockerfile

Now I feel confident enough to create a Dockerfile to automate all these steps. Let's create a file named Dockerfile (touch Dockerfile if you are on a Unix-like system (Linux or MacOS), or type nul > Dockerfile if you are on Windows) and paste the following content.

FROM php:latest

# Install unzip
RUN apt update && apt install -y unzip

# Install Composer using another strategy but with the same result
RUN curl -sS https://getcomposer.org/installer | php -- --install-dir=/usr/local/bin --filename=composer

# Set the environment variables
ENV HOME="/root"
ENV PATH="/root/.composer/vendor/bin:${PATH}:/root/.bun/bin"

# Install Bun
RUN curl -fsSL https://bun.sh/install | bash

# Create some symlinks to the bun executable
RUN ln -s $(which bun) /usr/local/bin/npm
RUN ln -s $(which bunx) /usr/local/bin/npx

# Install Laravel Installer
RUN composer global require laravel/installer

# Install pcntl extension
RUN docker-php-ext-install pcntl

Now let's build the image.

docker build -t laravel12 .

This command will create an image named laravel12 based on the Dockerfile we just created. At this point, the file is no longer needed, so feel free to delete it.

In this step we just created an image on our local Docker daemon. If you want to share this image with others, you can push it to a Docker registry. But this is a topic for another time. Anyway, I have pushed this image to my Docker Hub account and it is available for you to use.
docker pull ranierivalenca/laravel12

Testing

With the image created and registered on the local Docker daemon, we can now create a container with it.

docker run -it --rm laravel12 bash

If everything went well, you should be inside the container. Now we can create a Laravel project.

Creating a Laravel project

Okay, let's take a moment to recap what we have done so far. We have created a Dockerfile that creates a container with all the dependencies needed to run a Laravel 12 project. We have built the image and were able to create a container with it. If now we create a Laravel project inside this container, all the project's files will be inside the container and will be lost when the container stops. To avoid this, we can create a volume to store the project's files on the host system.

docker run -it --rm -v $(pwd):/app laravel12 laravel new my-app

This way, we are creating a volume that maps the current directory ($(pwd)) to the /app directory inside the container. So, the my-app directory will be created inside the current directory on the host system. Now we can run the project.

cd my-app
docker run -it --rm -v $(pwd):/app -w /app laravel12 composer run dev

This command will create a container with the my-app (now the current directory thanks to cd command) directory mounted on the /app directory inside the container. It will also set the working directory to /app (so we don't have to type /app on every command or do a cd command).

Tadah! It's running. Unfortunately, we can't access the project on the browser because we didn't expose any ports. And, moreover, by default (at this present time at least), the composer run dev command start both PHP and Vite (JS) servers bound to 127.0.0.1 (localhost). This is fine when we are running the project directly on the host system, but not when we are running it inside a container. Even if we expose the ports, the app inside the container won’t respond to requests from the host system because it’s bound to 127.0.0.1.

All this can look a bit confusing, but it's not that hard. In summary, all we have to do is to change the artisan serve command to bind to 0.0.0.0 and add a --host option to the npm run dev command. We can do this by editing the composer.json file.

sed -i 's/artisan serve/artisan serve --host 0.0.0.0/g' composer.json
sed -i 's/run dev/run dev --host/g' composer.json

If you are using Windows, you can use the sed command on Git Bash or WSL. If you are using PowerShell, you can use the Get-Content and Set-Content cmdlets. If you are using MacOS, the sed -i command expects an argument after the -i option, so you can use sed -i ''.

Now we can run the project again., exposing the ports.

docker run -it --rm -v $(pwd):/app -w /app -p 8000:8000 -p 5173:5173 laravel12 composer run dev

Now we can access the project on your browser at http://localhost:8000.

Extending the Dockerfile and dependencies

As I mentioned before, this specific Laravel 12 project requires a MongoDB database. So, we have to install the MongoDB PHP extension. We also need to have a MongoDB server running. Let's break this down into steps.

Adding the MongoDB PHP extension

Luckily, the PHP image has some scripts that may help us to install PHP extensions. Let's try using the most basic one, the docker-php-ext-install script. Like before, I'll make some real-world testing before adding it to the Dockerfile.

docker run -it --rm laravel12 bash
# Inside the container
docker-php-ext-install mongodb

Oops. It didn't work. The mongodb extension isn't available on the /usr/src/php/ext directory that came with our PHP image. We'll have to install it manually. Let's try to install it using PECL.

pecl install mongodb

The installation process will ask you some questions. Just press Enter to accept the default values. You can check this options on the PECL site, on the MongoDB site or on the PHP site.

Now (after a while - this is a kinda big extension), the extension is built and installed, but we need to enable it. Let's do this using another (very pleasant) PHP script.

docker-php-ext-enable mongodb

To ensure everything is working, let's check if the extension is installed and enabled.

php -m | grep mongodb

And we're done! Now we can exit the container and add these commands to a new Dockerfile that will use the laravel12 image as the base image.

FROM laravel12

# Install the MongoDB PHP extension
RUN pecl install mongodb && docker-php-ext-enable mongodb

You'll find that this process is very similar to the one we used to install the pcntl extension. The main difference is that we are using the pecl command instead of the docker-php-ext-install command.

Using this new Dockerfile, we can build a new image and create a container with it. We can also test if the MongoDB PHP extension is installed and enabled.

docker build -t laravel12:with-mongodb .
docker run -it --rm laravel12:with-mongodb php -m | grep mongodb

Using this approach, we can now install any PHP extension we need. We just have to find the right package name and use either the docker-php-ext-install or pecl install plus docker-php-ext-enable commands depending on the extension.

If this matches your needs, you can get this image from my Docker Hub account.
docker pull ranierivalenca/laravel12:with-mongodb

Adding the MongoDB server

To run a MongoDB server, we can use the official MongoDB image. We can create a container with this image and run it in the background. We can also expose the default MongoDB port (27017) to the host system.

docker run -d --name mongodb -p 27017:27017 --network-alias mongo mongo

This command creates a container named mongodb with the mongo image, exposing the default MongoDB port (27017) to the host system (in case you want to access it externally) and assigning it the alias mongo in Docker’s internal network. Now we can connect to this server from our Laravel project through the mongo hostname - just remember your project will be running inside a container connected to the same (docker) network as the MongoDB server.

Conclusion

I hope you enjoyed this journey as much as I did! I learned a lot, and I hope you did too. I’m pleased with the results and the journey that led me here — I hope you are too! If you have any questions, suggestions or corrections, please let me know. I’m always open to learning new things and improving my knowledge.

Banco de dados no Desenvolvimento Web

Ranieri Valença — Tue, 17 Oct 2023 15:56:44 +0000

Introdução - Bancos de Dados como a Base do Desenvolvimento Web

O universo da tecnologia e do desenvolvimento web tem, como sua base fundamental, os dados. Em essência, as aplicações web são construídas para proporcionar a disponibilidade, organização e manipulação eficaz dessas informações. É por esse motivo que o entendimento sobre bancos de dados se torna crucial nesse contexto.

Banco de Dados vs. Sistema de Gerenciamento de Banco de Dados (SGBD)

Antes de mergulharmos nos detalhes dos bancos de dados e dos SGBDs, é importante esclarecer as diferenças entre esses termos, frequentemente usados de forma intercambiável. Em essência, um banco de dados é uma estrutura que serve para armazenar informações, enquanto um Sistema de Gerenciamento de Banco de Dados (SGBD) é uma aplicação ou software específico projetado para gerenciar e facilitar o acesso a esses dados.

Banco de Dados: Esta é a entidade que atua como o repositório central para armazenar informações. Ele é o local onde os dados são organizados, estruturados e, em última análise, armazenados.

SGBD: Por outro lado, o SGBD é a ferramenta que permite aos usuários interagirem com o banco de dados. Ele oferece uma variedade de funcionalidades, como inserção, atualização, exclusão e recuperação de dados. O SGBD também é responsável por garantir a segurança, a integridade e a consistência dos dados.

Neste contexto, MySQL, PostgreSQL, Oracle, SQL Server, Firestore (Firebase), MongoDB e outros são SGBDs, softwares que facilitam e gerenciam o acesso aos dados contidos em seus repositórios (bancos de dados), sendo os dois últimos exemplos de SGBDs NoSQL (Not Only SQL).

Bancos de Dados Relacionais e Não Relacionais

Na introdução acima, citamos os termos SQL e NoSQL. SQL é uma linguagem de consulta (Structured Query Language) desenvolvida para manipular e acessar dados contidos em bancos de dados relacionais. Um banco de dados relacional refere-se a uma forma de organização de dados que utiliza tabelas para armazenar informações. Essas tabelas são interconectadas por meio de chaves e relacionamentos definidos, seguindo um modelo predefinido.

No entanto, existem outros tipos de bancos de dados que não se encaixam nesse modelo relacional. Eles são conhecidos como bancos de dados NoSQL (Not Only SQL), e são projetados para lidar com tipos de dados mais variados e flexíveis, como documentos, gráficos, pares chave-valor, entre outros. Aqui estão algumas informações adicionais sobre essas categorias:

Bancos de Dados Relacionais

Os bancos de dados relacionais são baseados em um modelo de dados tabular, onde as informações são organizadas em tabelas com linhas e colunas. As relações entre essas tabelas são estabelecidas por meio de chaves primárias e estrangeiras. Alguns exemplos populares de SGBDs relacionais incluem:

MySQL: Um SGBD de código aberto amplamente usado que é conhecido por sua velocidade e confiabilidade.
PostgreSQL: Um SGBD de código aberto conhecido por seu alto desempenho e suporte a recursos avançados.
Oracle: Um SGBD comercial amplamente utilizado em empresas, conhecido por sua escalabilidade e recursos de segurança.
SQL Server: Um SGBD da Microsoft com recursos avançados, como integração com o ambiente Windows.

Bancos de Dados NoSQL

Os bancos de dados NoSQL se destacam por sua flexibilidade e capacidade de lidar com tipos de dados variados. Eles não dependem do modelo tabular rígido dos bancos de dados relacionais. Em vez disso, eles utilizam modelos de dados mais diversos, como:

Documentos: Nesse modelo, os dados são armazenados em documentos semelhantes a JSON ou BSON. O MongoDB é um exemplo popular desse tipo.
Grafos: Projetados para armazenar dados em forma de nós e arestas, excelentes para representar relações complexas. O Neo4j é um SGBD de gráfico bem conhecido.
Chave-Valor: Eles armazenam dados como pares chave-valor simples, sendo ideais para cenários de armazenamento em cache e recuperação rápida de informações. O Redis é um exemplo notável.
Colunas amplas: Esses bancos de dados armazenam dados em colunas, permitindo consultas eficientes em grandes conjuntos de dados. O Cassandra é um exemplo.

Modelagem de Dados e Modelo Entidade-Relacionamento

A modelagem de dados é um processo essencial no projeto de bancos de dados. Ela envolve a definição de como os dados serão estruturados, organizados e relacionados. Um dos métodos mais comuns de modelagem de dados é o Modelo Entidade-Relacionamento (ER), que utiliza diagramas para representar entidades, atributos e relacionamentos entre eles.

Entidades: São objetos ou conceitos que armazenam informações e que visam modelar "coisas" do mundo real. Por exemplo, em um sistema de gerenciamento escolar, "Aluno" e "Professor" seriam entidades.

Atributos: São as características ou propriedades das entidades. No caso de um aluno, os atributos podem incluir "Nome", "Idade" e "Endereço".

Relacionamentos: Definem como as entidades estão conectadas umas às outras. Por exemplo, um relacionamento "Ensina" pode conectar a entidade "Professor" à entidade "Matéria".

A modelagem de dados é crucial para garantir que o banco de dados atenda aos requisitos do sistema e que as consultas possam ser executadas de maneira eficiente.

Mais alguns conceitos sobre Bancos de Dados

Modelo Físico

Além do modelo lógico, que descreve a estrutura de dados em um nível abstrato, existe o modelo físico, que se concentra na implementação real do banco de dados em hardware específico. Isso inclui considerações sobre como os dados serão armazenados em disco, quais índices serão usados para otimizar as consultas e como os backups e a recuperação serão gerenciados.

Transações

As transações são operações de banco de dados que envolvem uma ou mais ações. Elas garantem que um conjunto de operações seja executado de forma atômica, ou seja, todas as operações são bem-sucedidas ou nenhuma delas é executada. Isso garante a integridade dos dados, especialmente em ambientes de bancos de dados multiusuário.

Conexão com o SGBD

Como falamos, o SGBD é um software que visa facilitar o acesso aos dados. Ao invés de tratarmos com arquivos CSV como fizemos em exemplos anteriores nesta série, podemos manter os dados de nossa aplicação dentro de um banco de dados, sendo este banco gerenciado por um SGBD.

Num nível mais baixo de abstração, um SGBD (relacional ou não) funciona como um software servidor, que espera por uma conexão de um cliente. No caso de SGBDs relacionais, o cliente que fará a conexão será a interface a partir da qual o desenvolvedor irá enviar os comandos em SQL e, eventualmente, ler os dados retornados pelo servidor do SGBD.

Este software cliente pode ser uma interface visual, como o MySQL Workbench, uma interface de linha de comando (CLI - command line interface) como o psql ou o mysql (executáveis a partir de um terminal de comando) ou um outro software qualquer, escrito em alguma linguagem de programação e que interage com um driver de acesso.

Driver

Um driver, no contexto de conexão com um Sistema de Gerenciamento de Banco de Dados (SGBD), é um componente de software responsável por permitir que uma aplicação se comunique e interaja com o banco de dados. Ele age como uma ponte entre a aplicação, que está escrita em uma linguagem de programação específica, e o SGBD, que pode ter seu próprio conjunto de protocolos de comunicação.

Funcionalidade dos Drivers

Os drivers desempenham várias funções essenciais:

Conexão com o Banco de Dados: O driver estabelece a conexão inicial entre a aplicação e o banco de dados. Ele lida com os detalhes de comunicação, como endereço do servidor, autenticação e configurações de segurança.
Tradução de Comandos: Quando a aplicação envia comandos SQL para o SGBD, o driver traduz esses comandos para um formato que o banco de dados possa entender e processar. Isso é fundamental, pois diferentes SGBDs podem ter dialetos SQL ligeiramente diferentes.
Gerenciamento de Conexão: Os drivers gerenciam a alocação e o encerramento de conexões com o banco de dados. Isso inclui a criação de novas conexões quando necessário e a reutilização de conexões existentes para melhorar o desempenho.
Prevenção de Injeção SQL: Muitos drivers têm medidas de segurança embutidas para evitar ataques de injeção SQL. Eles garantem que os comandos SQL inseridos pela aplicação sejam seguros e não representem uma ameaça à integridade dos dados.
Manipulação de Resultados: Quando o SGBD retorna resultados de consultas, o driver os processa e os transforma em um formato compreensível para a aplicação. Isso pode incluir a conversão de tipos de dados e a estruturação dos resultados em objetos ou arrays utilizáveis.

Onde os Drivers São "Instalados"

Os drivers geralmente fazem parte da pilha de tecnologia da aplicação e são incluídos no código ou referenciados como bibliotecas externas, dependendo da linguagem de programação utilizada. Eles são específicos para cada SGBD, o que significa que você precisa do driver correto para se conectar a um determinado banco de dados.

Por exemplo, em PHP, você pode utilizar extensões como mysqli ou PDO (PHP Data Objects) para se conectar a diferentes SGBDs, e essas extensões incluem os drivers necessários para cada SGBD.

Exemplos de Conexão com MySQL em PHP

Em PHP, a conexão com um banco de dados é frequentemente feita usando drivers específicos. Aqui estão dois exemplos de como se conectar a um banco de dados MySQL e PostgreSQL usando as extensões mysqli e PDO:

`mysqli`

<?php
$host = "localhost"; // host onde o servidor de MySQL estará escutando
$port = 3306; // porta TCP onde o servidor escuta
$username = "seu_usuario"; // usuário do SGBD
$password = "sua_senha"; // senha do usuário
$database = "seu_banco"; // base de dados que será utilizada

// Criar uma conexão
$mysqli = new mysqli($host, $username, $password, $database, $port); // o argumento $port é opcional; o valor default é a porta padrão (3306 para o MySQL)

// Verificar se a conexão foi bem-sucedida
if ($mysqli->connect_error) {
    die("Erro de conexão: " . $mysqli->connect_error);
}

// Exemplo de comando INSERT
$insertQuery = "INSERT INTO tabela (coluna1, coluna2) VALUES ('valor1', 'valor2')";
if ($mysqli->query($insertQuery) === true) {
    echo "Inserção bem-sucedida.";
} else {
    echo "Erro na inserção: " . $mysqli->error;
}

// Exemplo de comando SELECT
$selectQuery = "SELECT coluna1, coluna2 FROM tabela WHERE algum_criterio";
$result = $mysqli->query($selectQuery);

if ($result->num_rows > 0) {
    while ($row = $result->fetch_assoc()) {
        echo "Coluna1: " . $row["coluna1"] . " - Coluna2: " . $row["coluna2"] . "<br>";
    }
} else {
    echo "Nenhum resultado encontrado.";
}

// Fechar a conexão
$mysqli->close();
?>

PDO

<?php
// Dados de conexão
$host = "localhost";
$port = 3306;
$username = "seu_usuario";
$password = "sua_senha";
$database = "seu_banco";

try {
    // Criar uma conexão
    $pdo = new PDO("mysql:host=$host;port=$port;dbname=$database", $username, $password); // a porta aqui também é opcional
} catch (PDOException $e) {
    die("Erro de conexão: " . $e->getMessage());
}

// Exemplo de comando INSERT
$insertQuery = "INSERT INTO tabela (coluna1, coluna2) VALUES (?, ?)";
$stmt = $pdo->prepare($insertQuery);
$valor1 = "valor1";
$valor2 = "valor2";
$stmt->execute([$valor1, $valor2]);
echo "Inserção bem-sucedida.";

// Exemplo de comando SELECT
$selectQuery = "SELECT coluna1, coluna2 FROM tabela WHERE algum_criterio";
$stmt = $pdo->query($selectQuery);

while ($row = $stmt->fetch(PDO::FETCH_ASSOC)) {
    echo "Coluna1: " . $row["coluna1"] . " - Coluna2: " . $row["coluna2"] . "<br>";
}
?>

Esses exemplos ilustram como os drivers são usados em PHP para conectar-se a diferentes SGBDs e interagir com eles. Cada linguagem de programação tem suas próprias maneiras de lidar com drivers de banco de dados, mas o princípio geral é semelhante: o driver atua como a interface entre a aplicação e o SGBD, facilitando a comunicação e a manipulação de dados.

Esses exemplos também são uma base sólida para realizar operações de banco de dados em PHP. Certifique-se de adaptá-los às suas necessidades específicas, substituindo os nomes de tabela, colunas e valores de acordo com o seu banco de dados e aplicação.

Conclusão

Os bancos de dados desempenham um papel central no desenvolvimento web, fornecendo a estrutura para armazenar e recuperar dados de forma eficiente. Compreender os aspectos fundamentais, como a modelagem entidade-relacionamento, é essencial para projetar sistemas de bancos de dados que atendam aos requisitos de desempenho e confiabilidade. Saber conectar aos SGBDs e manipular bancos de dados utilizando linguagens de programação pode ser inicialmente desafiador, por requerer conhecimentos em duas áreas distintas (às vezes mais, quando tratamos de aplicações mais complexas), mas é um aspecto fundamental no desenvolvimento de aplicações em geral, principalmente no universo Web.

Introdução ao Docker: Simplificando a Gestão de Aplicações

Ranieri Valença — Sat, 19 Aug 2023 15:24:01 +0000

Tópicos

1. Introdução
2. Revisão de Sistemas Operacionais e Virtualização
       2.1. Kernel do SO
             a. Processos e Isolamento de Processos
             b. Gestão de Memória
             c. Sistema de Arquivos
       2.2. Virtualização
             a. Virtualização de Hardware
             b. Virtualização de Sistema Operacional
3. O que é Docker?
       3.1. Imagens
       3.2. Container
       3.3. Volumes
       3.4. Redes
       3.5. Compartilhamento de portas com o SO Host
       3.6. Docker Registry
       3.7. Dockerfile
       3.8. Docker compose
4. Conclusão

Introdução

Nos últimos anos, o desenvolvimento e a implantação de aplicativos têm sido transformados por tecnologias inovadoras que visam simplificar e agilizar todo o processo. Uma dessas tecnologias que ganhou enorme popularidade é o Docker. Com a capacidade de empacotar, distribuir e executar aplicativos em ambientes isolados, o Docker trouxe uma abordagem revolucionária para a criação de ambientes de desenvolvimento e produção consistentes e escaláveis. Neste artigo, vamos explorar os fundamentos do Docker e como ele está mudando a forma como os aplicativos são desenvolvidos e implantados.

Revisão de Sistemas Operacionais e Virtualização

Antes de explorarmos mais a fundo o Docker e seus conceitos, é importante revisarmos alguns aspectos fundamentais dos sistemas operacionais e entender como eles estão relacionados com a virtualização, uma vez que o Docker utiliza uma tecnologia específica de virtualização de containers.

Kernel do SO

O Kernel é o núcleo do sistema operacional, responsável por gerenciar recursos e fornecer serviços aos processos e aplicativos. Ele controla o acesso ao hardware, a execução de processos, a alocação de memória, entre outras tarefas essenciais. O kernel atua como uma camada de abstração entre o hardware e os programas em execução. A seguir vamos falar sobre algumas atribuições do Kernel de um Sistema Operacional.

Processos e Isolamento de Processos

Um processo é uma instância em execução de um programa. O isolamento de processos é um conceito-chave em sistemas operacionais, que garante que os processos não interfiram uns nos outros. Cada processo possui seu próprio espaço de endereçamento de memória, registradores, pilha e outras estruturas de dados. Isso evita conflitos e garante que um processo não acesse a memória de outro sem permissão.

Gestão de Memória

A gestão de memória é crucial para otimizar o uso dos recursos do sistema. Os sistemas operacionais são responsáveis por alocar e desalocar memória para os processos, bem como garantir a proteção da memória entre os processos. Mecanismos como paginação e segmentação são utilizados para permitir o compartilhamento seguro da memória entre processos.

Sistema de Arquivos

O sistema de arquivos é a estrutura que organiza e armazena os dados em dispositivos de armazenamento, como discos rígidos e SSDs. Ele permite a criação, leitura, gravação e exclusão de arquivos e diretórios. Os sistemas operacionais fornecem interfaces para acessar e manipular arquivos, gerenciando o armazenamento físico e a hierarquia de diretórios.

Virtualização

De forma simplória, a virtualização é uma tecnologia que permite a criação de ambientes isolados e independentes, chamados de máquinas virtuais (VMs), dentro de um sistema hospedeiro. Ela oferece uma forma de executar múltiplos sistemas operacionais ou ambientes de software em uma única máquina física. Dois principais tipos de virtualização são relevantes para entender o Docker:

Virtualização de Hardware

Nesse modelo, uma camada de software chamada hipervisor é executada no hardware físico. O hipervisor gerencia a alocação de recursos entre as várias VMs. Cada VM contém um sistema operacional completo, incluindo kernel, processos e bibliotecas. Isso oferece um alto grau de isolamento, mas também pode ser mais pesado em termos de recursos, uma vez que cada VM inclui um sistema operacional completo.

Virtualização de Sistema Operacional

Também conhecida como virtualização de containers, essa abordagem compartilha o mesmo kernel entre o sistema hospedeiro e os containers. Os containers isolam processos e ambientes de execução, permitindo a execução de aplicativos em ambientes encapsulados. Isso resulta em menor sobrecarga, pois não há necessidade de múltiplos kernels. A virtualização de containers é mais eficiente em termos de recursos e oferece uma forma ágil de empacotar, distribuir e executar aplicativos.

O que é Docker?

O Docker é uma plataforma de código aberto que permite criar, implantar e executar aplicações em containers. Um container é uma unidade de software que contém todas as dependências necessárias para executar uma aplicação, incluindo o código, bibliotecas, ambientes de tempo de execução e configurações. Essa abordagem de containers possibilita que as aplicações sejam isoladas em ambientes consistentes e portáveis, garantindo que elas funcionem de maneira confiável em diferentes ambientes.

O Docker opera em um sistema operacional host, que é o sistema operacional do usuário. No caso de sistemas baseados em Unix como Linux ou MacOS, o Docker é executado diretamente sobre o SO nativo. Já no Windows, o Docker pode ser executado através do Hyper-V ou da plataforma de virtualização WSL (Windows Subsystem for Linux) da Microsoft. No caso do uso do WSL, o Docker ainda compartilha o kernel do sistema operacional Linux emulado. Isso proporciona eficiência em termos de recursos, já que os containers não precisam virtualizar todo o hardware.

Imagens

As imagens Docker são a espinha dorsal de como o Docker trabalha. Uma imagem é um modelo somente leitura que contém todos os componentes necessários para executar um aplicativo, incluindo o código-fonte, as bibliotecas, as dependências e os arquivos de configuração. Elas servem como base para criar containers.

Uma imagem é construída a partir de um arquivo chamado Dockerfile, que contém instruções para definir o ambiente do aplicativo. Ele especifica a partir de qual imagem base começar, quais comandos executar para configurar o ambiente e como o aplicativo será inicializado.

Container

Os containers são instâncias em tempo de execução de imagens. Eles encapsulam um ambiente isolado para a execução de um aplicativo, incluindo seu sistema de arquivos, variáveis de ambiente, bibliotecas e processos em execução. Os containers são leves e compartilham o mesmo kernel do sistema operacional host, o que resulta em uma utilização eficiente de recursos.

Cada container é isolado dos outros, o que significa que os processos em execução em um container não interferem nos processos de outros containers. Isso proporciona uma excelente maneira de garantir a consistência e a separação entre os aplicativos, mesmo quando estão todos sendo executados no mesmo host.

Volumes

Os volumes no Docker são mecanismos que permitem persistir dados além do ciclo de vida de um container. Eles são usados para compartilhar dados entre o host e os containers ou entre containers diferentes. Um volume é um diretório ou arquivo no sistema de arquivos do host que é montado em um determinado ponto dentro do container.

Os volumes são particularmente úteis para armazenar dados que precisam ser mantidos entre a inicialização e o encerramento do container, como bancos de dados ou arquivos de configuração. Eles também são uma forma de compartilhar dados entre containers que precisam colaborar. Além disso, eles podem ser utilizados como forma de manter o código fonte de um software no SO Host, acessível ao desenvolvedor, enquanto sua execução é feita dentro de um container.

Redes

As redes Docker permitem a comunicação entre containers em diferentes hosts ou no mesmo host. Elas são usadas para conectar containers que precisam se comunicar uns com os outros, seja para trocar dados ou para formar componentes de um aplicativo distribuído.

As redes Docker podem ser configuradas para diferentes modos de comunicação, como modo bridge (ponte) para comunicação interna entre containers ou modo host para comunicação direta com a rede do host. Isso permite criar ambientes complexos em que os containers podem se comunicar de maneira eficiente e segura.

Compartilhamento de portas com o SO Host

Os containers podem expor portas para o host e para a rede externa. Isso permite que os aplicativos sejam acessados através de interfaces de rede, tornando-os disponíveis para os usuários e para outros sistemas.

Docker Registry

O Docker Registry é um repositório para armazenar e compartilhar imagens Docker. Ele é essencial para compartilhar imagens entre desenvolvedores e implantações. O Docker Hub é um exemplo de um Docker Registry público (repositório padrão), onde você pode encontrar imagens prontas para uso em diferentes cenários.

Você também pode configurar seu próprio Docker Registry privado para armazenar imagens internamente. Isso é especialmente útil quando você deseja manter o controle sobre as imagens usadas em sua organização ou quando precisa lidar com requisitos de segurança mais rigorosos.

`Dockerfile`

Um Dockerfile é um arquivo de texto que contém um conjunto de instruções para criar uma imagem Docker. Ele é a base para construir imagens personalizadas que atendam às necessidades específicas do aplicativo.

No Dockerfile, você pode especificar uma imagem base, instalar pacotes e bibliotecas adicionais, configurar variáveis de ambiente, copiar arquivos para dentro da imagem e definir como o aplicativo será iniciado. Esse arquivo é usado pelo Docker para automatizar a criação de imagens de maneira consistente e reprodutível.

A seguir, um exemplo de um Dockerfile:

# Usar uma imagem base
FROM node:14

# Definir o diretório de trabalho
WORKDIR /app

# Copiar os arquivos de configuração
COPY package.json package-lock.json /app/

# Instalar as dependências
RUN npm install

# Copiar o restante dos arquivos da aplicação
COPY . /app/

# Expor a porta que a aplicação irá escutar
EXPOSE 3000

# Comando para iniciar a aplicação
CMD ["npm", "start"]

Docker compose

O Docker Compose é uma ferramenta que permite definir e executar aplicativos compostos por vários containers. Com um único arquivo de configuração, é possível definir a estrutura do aplicativo, suas dependências e como eles devem se comunicar.

O arquivo de configuração do Docker Compose é escrito em YAML (docker-compose.yml) e pode definir vários serviços, redes e volumes. Ele fornece uma maneira fácil de iniciar e gerenciar aplicativos complexos, permitindo que você descreva a arquitetura do aplicativo e suas interações de forma clara e concisa.

Linguagem YAML (YAML Ain't Markup Language)

YAML é uma linguagem de marcação leve que é frequentemente utilizada para configuração de dados estruturados. Ela é bastante legível para humanos e utiliza espaços e indentação para definir a estrutura dos dados. O YAML é comumente usado em arquivos de configuração, como o docker-compose.yml, para definir serviços, configurações e relacionamentos entre diferentes componentes.

A seguir, dois exemplos de arquivos docker-compose.yml:

version: '3'
services:
  webapp:
    build:
      context: .  # Diretório onde está localizado o Dockerfile
    ports:
      - '3000:3000'

Neste exemplo, estamos definindo um serviço chamado 'webapp'. Estamos indicando que ele deve ser construído usando o Dockerfile no mesmo diretório (context: .) e mapeando a porta 3000 do host para a porta 3000 do container.

version: '3'
services:
  mysql:
    image: mysql:5.7
    environment:
      MYSQL_ROOT_PASSWORD: mysecretpassword
      MYSQL_DATABASE: mydatabase
    volumes:
      - mysql-data:/var/lib/mysql

  webapp:
    image: php:7.4-apache
    ports:
      - '80:80'
    volumes:
      - ./webapp:/var/www/html
    depends_on:
      - mysql

volumes:
  mysql-data:

Já neste exemplo, temos dois serviços: mysql e webapp.

O serviço mysql utiliza a imagem oficial do MySQL 5.7 e configura algumas variáveis de ambiente, como a senha do root e o nome do banco de dados. O uso de volumes permite persistir os dados do banco de dados fora do container.
O serviço webapp utiliza a imagem oficial do PHP 7.4 com o servidor Apache. Ele mapeia a porta 80 do host para a porta 80 do container e monta o diretório local ./webapp no diretório /var/www/html do container. Isso permite que você desenvolva a aplicação localmente e veja as alterações refletidas imediatamente no container.

Além disso, o serviço webapp depende do serviço mysql, o que garante que o container do banco de dados esteja em execução antes do container da aplicação web.

Por fim, um volume chamado mysql-data é definido para persistir os dados do banco de dados em um volume Docker, tornando os dados persistentes mesmo quando os containers são reiniciados ou atualizados.

O Docker Compose simplifica a criação e gerenciamento de ambientes de desenvolvimento complexos, permitindo que você defina e execute vários serviços interconectados com facilidade.

Conclusão

A revolução trazida pelo Docker na forma como desenvolvemos, implantamos e gerenciamos aplicativos é inegável. Com uma abordagem baseada em containers, o Docker fornece uma maneira eficiente de criar, distribuir e executar aplicativos em ambientes isolados e consistentes. O uso de imagens, containers, volumes, redes e outras funcionalidades do Docker permite uma maior portabilidade, escalabilidade e facilidade de implantação.

Além disso, a compreensão dos conceitos fundamentais de sistemas operacionais, como o papel do kernel, isolamento de processos, gestão de memória e sistema de arquivos, é crucial para aproveitar ao máximo os benefícios oferecidos pelo Docker. A virtualização, tanto a de hardware quanto a de sistema operacional, também desempenha um papel fundamental na compreensão das tecnologias subjacentes ao Docker e de como ele consegue fornecer ambientes isolados de maneira eficiente.

O Dockerfile e o Docker Compose são ferramentas poderosas que simplificam a criação e o gerenciamento de ambientes de desenvolvimento complexos. O uso do Docker Registry, seja público ou privado, amplia ainda mais a flexibilidade e a eficiência do desenvolvimento e implantação de aplicativos.

Em resumo, o Docker representa um divisor de águas na maneira como desenvolvemos e entregamos software. Sua abordagem baseada em containers oferece uma solução altamente eficiente e flexível para a criação e execução de aplicativos, independentemente do ambiente em que serão implantados. Portanto, investir tempo para entender os conceitos por trás do Docker e aprender a trabalhar com suas ferramentas pode ser extremamente benéfico para profissionais de desenvolvimento, operações e outras áreas relacionadas.

Front-End, Back-End, CRUD, REST, APIs e outros conceitos importantes sobre Desenvolvimento Web

Ranieri Valença — Wed, 02 Aug 2023 18:04:42 +0000

Tópicos

1. Front-End e Back-End: Entendendo as Diferenças
       1.1. Front-End
             a. Principais Responsabilidades do Front-End
       1.2. Back-End
             a. Principais Responsabilidades do Back-End
       1.3. Integração Front-End e Back-End
2. CRUD - Create, Read, Update e Delete
       2.1. CRUD no Back-End e Interação com Fontes de Dados
       2.2. CRUD do Ponto de Vista do Usuário
3. API
4. REST
5. Tokens, JWT e seu Uso com APIs REST
6. Outros Modelos de API
7. Conclusão

Front-End e Back-End: Entendendo as Diferenças

No desenvolvimento de aplicações web, é comum encontrar dois termos fundamentais: Front-End e Back-End. Esses termos se referem a diferentes camadas de uma aplicação e descrevem as responsabilidades e funções específicas de cada uma. Compreender as diferenças entre Front-End e Back-End é essencial para entender a estrutura geral de uma aplicação web e como suas diferentes partes interagem.

Front-End

O Front-End é a parte da aplicação web com a qual os usuários interagem diretamente. Ele é responsável por apresentar o conteúdo e a interface visual da aplicação, tornando-a acessível e amigável aos usuários. Os desenvolvedores de Front-End utilizam tecnologias como HTML, CSS e JavaScript para construir a interface gráfica e a experiência do usuário.

Principais Responsabilidades do Front-End

Estrutura e Conteúdo: O HTML (HyperText Markup Language) é usado para criar a estrutura básica da página e definir o conteúdo, como texto, imagens e vídeos.
Estilo e Layout: O CSS (Cascading Style Sheets) é responsável pela aparência visual da página, incluindo cores, fontes, tamanhos, posicionamento de elementos e layouts responsivos.
Interatividade: O JavaScript é utilizado para tornar a página interativa, permitindo que os elementos respondam a ações do usuário, como cliques, arrastar e soltar, animações e muito mais, além de ser utilizado para manipulação de dados antes do envio ao back-end.
Compatibilidade com Dispositivos: O Front-End deve garantir que a aplicação funcione de forma adequada em diferentes dispositivos, como computadores, tablets e smartphones. Isso é geralmente resultante de interações do CSS com o JavaScript.

Back-End

O Back-End é a parte "invisível" da aplicação web, que fica nos bastidores (em aplicações web, esta é a parte que fica hospedada em um servidor) e é responsável por gerenciar a lógica de negócios, o processamento de dados e a interação com fontes externas (apesar desta interação também poder ser feita, em alguns casos, diretamente do front-end com a ajuda de JavaScript e das APIs do navegador), como bancos de dados e serviços de terceiros. Os desenvolvedores de Back-End trabalham principalmente com linguagens de programação como PHP, Python, Ruby, Java, Node.js, entre outras.

Principais Responsabilidades do Back-End

Lógica de Negócios: O Back-End é responsável por implementar as regras de negócio da aplicação, como cálculos, validações e processamento de dados.
Armazenamento e Recuperação de Dados: O Back-End gerencia a interação com o banco de dados ou outra fonte de dados (como por exemplo arquivos CSV), permitindo a criação, leitura, atualização e exclusão de dados (operações CRUD).
Autenticação e Segurança: É no Back-End que são implementados os sistemas de autenticação e autorização para garantir que apenas usuários autorizados tenham acesso a determinados recursos e informações sensíveis.
Integração de APIs: O Back-End pode interagir com serviços de terceiros ou outras APIs, permitindo que a aplicação acesse recursos externos, como envio de e-mails, integração com redes sociais, entre outros.

Integração Front-End e Back-End

Uma aplicação web bem-sucedida requer uma estreita integração entre o Front-End e o Back-End. O Front-End precisa se comunicar com o Back-End para enviar e receber dados, realizar ações e atualizar a interface em tempo real. Isso é frequentemente feito por meio de chamadas de API, onde o Front-End envia solicitações ao Back-End para obter ou enviar informações.

A separação entre Front-End e Back-End permite que diferentes equipes de desenvolvimento trabalhem em paralelo, tornando o processo de desenvolvimento mais eficiente e organizado. Além disso, essa divisão de responsabilidades facilita a manutenção, atualização e escalabilidade da aplicação à medida que ela cresce e evolui.

É importante frisar que, a depender das escolhas de projeto durante o desenvolvimento, nem sempre é possível garantir esta separação. Por exemplo, em aplicações mais simples utilizando PHP (como a que vamos construir em breve), quando o usuário fizer uma requisição para o servidor, este retornará uma resposta com seus conteúdos HTML, CSS e JavaScript, resposta esta que irá gerar o front-end ao chegar no cliente.

Em resumo, pode-se dizer que front-end é aquilo com o que o usuário interage, o HTML e CSS utilizado para renderizar a interface gráfica no navegador e o JavaScript que lida com as ações do usuário no lado do cliente. Já o back-end é o código que fica hospedado no servidor e que é executado quando o mesmo recebe uma requisição.

CRUD - Create, Read, Update e Delete

O CRUD é uma sigla que representa as quatro principais operações básicas em sistemas de gerenciamento de informações:

Create (criar)
Read (ler)
Update (atualizar)
Delete (excluir).

Essas operações são amplamente utilizadas em aplicações web para manipular dados em um sistema.

CRUD no Back-End e Interação com Fontes de Dados

No contexto do desenvolvimento web, o CRUD é frequentemente implementado no back-end, que é a parte da aplicação que lida com o processamento dos dados e a interação com fontes de dados, como bancos de dados, arquivos CSV e outros serviços externos.

Create: Ao criar dados, o back-end recebe as informações enviadas pelo usuário (por meio de formulários ou chamadas de API) e as insere em um banco de dados ou outro repositório de armazenamento adequado.
Read: A operação de leitura envolve recuperar dados existentes do banco de dados ou fonte de dados correspondente e enviá-los de volta ao cliente (front-end) para exibição ou processamento adicional.
Update: Quando o usuário deseja modificar dados existentes, o back-end recebe a solicitação, verifica a validade das informações enviadas e, em seguida, atualiza os dados correspondentes no banco de dados.
Delete: A exclusão envolve remover dados específicos do banco de dados ou repositório de armazenamento, conforme solicitado pelo usuário.

CRUD do Ponto de Vista do Usuário

As operações de CRUD são geralmente realizadas em resposta às ações do usuário. Algumas vezes podemos ter sistemas onde estas operações são bem claras, com formulários específicos para tal. Entretanto, algumas ações do usuário podem levar a operações de CRUD de forma não explícita, como nos seguintes exemplos:

Sistema de Busca: Quando o usuário realiza uma busca, o back-end recebe a consulta, processa-a e retorna os resultados relevantes, seguindo a operação de leitura (Read).
Atualização de Status: Em algumas plataformas, o usuário pode alterar seu status para "Disponível", "Ocupado", entre outros. Esta simples alteração envia ao servidor o novo status que o usuário deseja e o back-end realiza uma operação de atualização (Update).
Adição ou Remoção de Comentários: Em plataformas de mídia social ou blogs, os usuários podem adicionar ou remover comentários em publicações existentes. Quando isso acontece, o back-end realiza a operação de criação (Create) ou exclusão (Delete) de comentários correspondentes.
Like e avaliações: Em algumas redes sociais é possível dar uma nota (rate) para um determinado recurso (por exemplo, escolher entre 1 a 5 estrelas para um produto) ou "dar um like" em alguma postagem. Estas operações geralmente envolvem a criação (Create) ou exclusão (Delete) de registros no banco de dados ou repositório, relacionando o usuário à postagem ou produto.

API

API é a sigla para "Interface de Programação de Aplicações" (Application Programming Interface, em inglês). É um conjunto de regras e protocolos que permite que diferentes aplicações se comuniquem entre si. As APIs definem os métodos e formatos de dados que podem ser utilizados para interagir com um sistema específico.

Uma API pode ser usada para permitir que aplicações externas acessem os recursos e funcionalidades de um sistema sem precisar conhecer a implementação interna desse sistema. Isso promove a modularidade, reutilização de código e integração de sistemas diferentes.

Portanto, o termo API é genérico o suficiente para incluir os diversos mecanismo de comunicação entre sistemas. Por exemplo, um Sistema Operacional fornece uma API para as linguagens de programação de baixo nível acessarem as interfaces de rede, ou acessarem o sistema de arquivos (como acontece quando usando a função fopen() do PHP, que solicita à API do Sistema Operacional um manipulador de arquivo).

Entretanto, no mundo do Desenvolvimento Web, o termo API é bastante utilizado para APIs REST, que veremos a seguir.

REST

REST é um estilo de arquitetura de software para sistemas distribuídos, geralmente utilizado na construção de APIs para aplicações web. REST é a sigla para "Representational State Transfer" (Transferência de Estado Representacional, em português).

Os princípios fundamentais do REST incluem:

Recursos Identificáveis: Cada recurso (como uma entidade em um banco de dados) deve ter um identificador único (URI) para acessá-lo de forma exclusiva.
Operações Baseadas em Métodos HTTP: As operações CRUD são mapeadas para os métodos HTTP: Create (POST), Read (GET), Update (PUT/PATCH) e Delete (DELETE).
Uso de HATEOAS: Hypermedia as the Engine of Application State (HATEOAS) é um princípio que sugere que as respostas das APIs devem conter links que permitem aos clientes descobrir e navegar para recursos relacionados.
Stateless (Sem Estado): Cada solicitação para o servidor deve conter todas as informações necessárias para compreender e processar a requisição. O servidor não deve armazenar o estado da sessão do cliente entre as requisições.

O REST facilita a criação de APIs escaláveis, flexíveis e de fácil manutenção, permitindo que diferentes aplicações se comuniquem de forma padronizada e eficiente.

Tokens, JWT e seu Uso com APIs REST

Tokens são uma forma de autenticação amplamente utilizada em aplicações web e APIs REST. Um token é uma sequência de caracteres que representa a autorização para acessar recursos ou executar operações específicas.

Token de Acesso: Um token de acesso é gerado após o usuário efetuar login e é enviado em cada requisição para a API. Ele permite que o cliente acesse recursos protegidos e realiza a autenticação do usuário em cada solicitação.
JSON Web Token (JWT): O JWT é um formato padrão para representar informações do usuário de forma segura entre duas partes. Ele é assinado digitalmente, o que garante que os dados no token não foram alterados após a sua criação.

O uso de tokens, como o JWT, é uma alternativa eficiente e segura para a autenticação de usuários em APIs REST. Em vez de depender de sessões no servidor, o token é armazenado no cliente (por exemplo, no armazenamento local ou em um cookie) e enviado em cada requisição. Isso torna a API mais escalável e não dependente de estado, permitindo fácil implementação de autenticação para aplicativos e serviços distribuídos.

Além do JWT (JSON Web Token), existem outros tipos de tokens utilizados em diferentes contextos no desenvolvimento web. Alguns exemplos incluem:

Tokens de Autenticação: São tokens usados para autenticar usuários e conceder acesso a recursos protegidos em uma aplicação. Além do JWT, outros formatos de token, como OAuth tokens e SAML tokens, são amplamente utilizados para autenticação e autorização em aplicações.
Tokens de Acesso: São tokens temporários que fornecem acesso a recursos ou serviços específicos em uma API. Eles são comumente usados em integrações de terceiros, onde os tokens são emitidos para clientes autorizados e revogados após um período de tempo ou quando o acesso é encerrado.
*Tokens de Atualização: São tokens utilizados em processos de autenticação em dois passos (2FA - 2 Factor Authentication). Após o usuário fornecer suas credenciais iniciais, um token de atualização é solicitado para confirmar a autenticação antes de conceder o acesso total à conta.
Tokens de Recuperação de Senha: São tokens gerados e enviados ao usuário para permitir a redefinição de senhas em caso de esquecimento. Esses tokens têm validade limitada e fornecem uma camada adicional de segurança ao processo de recuperação de conta.

Outros Modelos de API

Além do REST, existem outros modelos de API que podem ser utilizados em desenvolvimento web, como por exemplo:

GraphQL: É uma linguagem de consulta e manipulação de dados desenvolvida pelo Facebook. Com o GraphQL, o cliente pode especificar exatamente quais dados ele precisa, evitando sobrecarga de dados e tornando as requisições mais eficientes.
SOAP: É um protocolo mais antigo baseado em XML, amplamente utilizado em integrações corporativas. SOAP define uma estrutura rígida para as mensagens e é considerado mais pesado e complexo em comparação com as abordagens mais modernas, como REST e GraphQL.

Cada modelo de API tem suas próprias vantagens e pode ser mais adequado para diferentes cenários e requisitos específicos de uma aplicação. A escolha do modelo de API dependerá da complexidade do projeto, do tamanho da equipe de desenvolvimento, dos requisitos de performance e dos objetivos globais da aplicação.

Conclusão

Estes são alguns do conceitos mais fundamentais no mundo do Desenvolvimento Web, que todo desenvolvedor deve ter ciência. Obviamente este artigo fornece uma visão geral, e há muito mais detalhes a serem explorados sobre cada um destes tópicos, como por exemplo o funcionamento dos navegadores ao renderizar o front-end e como ele lida com as ações do usuário. Alguns destes tópicos serão abordados futuramente nesta série.

Cookies e Sessão - conceitos e utilização com PHP

Ranieri Valença — Fri, 28 Jul 2023 02:18:39 +0000

Tópicos

1. Introdução
2. Cookies
       2.1. Conceito
       2.2. Manipulação
             a. Criação de Cookies
             b. Leitura de Cookies
             c. Exclusão de Cookies
       2.3. Exemplo em PHP
3. Sessões
       3.1. Conceito
       3.2. Manipulação
             a. Criação de Sessões
             b. Leitura de Sessões
             c. Exclusão de Sessões
       3.3. Exemplo em PHP
4. Conclusão

Introdução

A palavra "sessão" em português é curiosa, pois tem a mesma sonoridade que cessão, seção e é muito similar à secção, cujos significados são completamente distintos. No contexto de Aplicações Web, o termo sessão representa um espaço de tempo durante o qual uma atividade específica é realizada, como a interação do usuário com um ambiente de web-email ou uma rede social.

Entretanto, o protocolo HTTP utilizado em Aplicações Web é stateless, o que significa que ele não mantém informações de estado ou identificação sobre quem está fazendo a requisição. Em aplicações mais complexas, essas informações são essenciais para personalizar a experiência do usuário e fornecer conteúdo relevante. Por exemplo, em uma rede social, é necessário saber quem está fazendo a requisição para gerar um feed personalizado para aquele usuário. É neste contexto que entram os Cookies e as Sessões.

Cookies

Conceito

Cookies são pequenos arquivos de texto armazenados no navegador do usuário. Eles foram criados para resolver o desafio da falta de estado (statelessness) no protocolo HTTP. Quando o servidor envia uma resposta para o navegador com o intuito de criar um cookie, o navegador armazena esses dados e, em seguida, envia-os de volta para o servidor em todas as requisições subsequentes relacionadas ao mesmo domínio. Dessa forma, os cookies permitem que as aplicações web mantenham informações sobre o usuário em requisições sucessivas ou até mesmo após ele navegar para outras páginas ou fechar o navegador.

Manipulação

A manipulação de cookies envolve três principais ações: criação, leitura e exclusão.

Criação de Cookies

Para criar um cookie, após uma requisição, o servidor envia um cabeçalho HTTP com a resposta que contém os dados do cookie que deseja armazenar no navegador do usuário. Esse cabeçalho geralmente é chamado de "Set-Cookie". Ele pode conter informações como nome, valor, data de expiração, domínio e caminho. Esses dados serão armazenados no navegador do usuário e enviados de volta para o servidor em todas as requisições futuras relacionadas ao mesmo domínio.

Leitura de Cookies

Quando o usuário navega para outras páginas ou faz novas requisições ao mesmo domínio, o navegador envia automaticamente os cookies relacionados a esse domínio no cabeçalho da requisição HTTP. O servidor pode então ler esses cookies e utilizar as informações armazenadas para personalizar a experiência do usuário ou fornecer conteúdo relevante.

Exclusão de Cookies

Para excluir um cookie, o servidor envia uma resposta HTTP com um cabeçalho "Set-Cookie" que instrui o navegador a remover o cookie do armazenamento local. Para fazer isso, geralmente é definida uma data de expiração passada, o que faz com que o cookie seja considerado inválido e, portanto, excluído pelo navegador.

Exemplo em PHP

Considere os seguintes códigos em PHP:

<!-- set_cookie.php -->
<?php
// Criando um cookie com o nome "usuario" e o valor "joao123"
setcookie("usuario", "joao123", time() + (86400 * 30), "/");

// Setando o código de resposta para 302 - Found
http_response_code(302);

// Adicionando o cabeçalho 'Location', que informará ao browser para onde o usuário deve ser redirecionado (qual o próximo request que deve ser feito)
header('Location: /');

<!-- index.php -->
<?php
// Verificando se o cookie "usuario" está definido
if(isset($_COOKIE['usuario'])) {
    // Obtendo o valor do cookie
    $usuario = $_COOKIE['usuario'];
    echo "Bem-vindo de volta, $usuario!";
} else {
    echo "Olá, visitante!"; // Caso o cookie não esteja definido
}
?>

Suponha que estes dois arquivos estão num diretório e que este é o diretório raiz de um servidor embutido do PHP escutando na porta 8080. Neste caso, quando o usuário fizer a primeira requisição para http://localhost:8080, o arquivo index.php será executado, e considerando o cenário que não há nenhum cookie salvo (o que acontece, por exemplo, quando se abre uma página usando a navegação anônima), a condição do if será falsa e será respondido "Olá, visitante".

Agora, considere que o usuário digitou em sua barra de endereço http://localhost:8080/set_cookie.php. Quando a requisição chegar no servidor, o código do arquivo set_cookie.php será executado e irá adicionar o cabeçalho "Set-Cookie" (através da função setcookie(), o cabeçalho "Location" utilizando a função header() e alterar o código de resposta para 302 (Found). Com isso, o navegador fará duas coisas:

Adicionar o cookie "usuario" com o valor "joao123", que expirará em 30 dias (86400 == um dia).
Com o código de resposta de redirecionamento, fará uma nova requisição para a URI contida no cabeçalho "Location" (/).

Nesta nova requisição o cookie usuario=joao123 será adicionado como um cabeçalho extra no pacote HTTP, já que sua data de expiração é posterior à data atual. Isso fará com que o código do if seja executado, já que nesta requisição há um cookie chamado "usuario". Note que o PHP utiliza a variável superglobal $_COOKIE, que se comporta como um array associativo de forma similar às variáveis $_GET e $_POST, acessando dados provenientes do pacote HTTP da requisição. Para mais informações, você pode ler a documentação $_COOKIE no manual do PHP.

Para mais informações sobre cookies, você pode acessar a página de Cookies HTTP no MDN

Sessões

Conceito

As sessões são uma abstração mais amigável e segura para gerenciar informações de estado do que os cookies. Enquanto os cookies são armazenados no lado do cliente, as sessões são armazenadas no servidor. Um cookie é usado para rastrear a sessão do usuário, mas os dados da sessão em si são armazenados no servidor, não no cookie.

Manipulação

A manipulação de sessões também envolve três ações principais: criação, leitura e exclusão.

Criação de Sessões

Ao criar uma sessão, o servidor gera um identificador exclusivo chamado "session ID" e o envia para o navegador do usuário por meio de um cookie (geralmente chamado de "PHPSESSID" em aplicações PHP). Esse cookie contém o ID da sessão, que é usado para identificar a sessão no servidor.

Leitura de Sessões

Quando o usuário faz uma requisição ao servidor, o navegador envia o cookie contendo o session ID associado à sessão atual. O servidor usa esse session ID para recuperar os dados da sessão correspondentes armazenados em seu sistema. Isso permite que o servidor identifique o usuário e acesse as informações da sessão associadas. Em PHP isso é feito através da combinação da função session_start() e da variável superglobal $_SESSION, conforme será exemplificado a seguir.

Exclusão de Sessões

A exclusão de uma sessão geralmente ocorre quando o usuário encerra sua interação com a aplicação ou quando a sessão expira por inatividade (ou seja, quando o cookie contendo o session ID expira). Nesse momento, o servidor pode limpar os dados da sessão armazenados no servidor e instruir o navegador a excluir o cookie contendo o session ID, invalidando assim a sessão atual. Em PHP isso pode ser feito através da função session_destroy().

Exemplo em PHP

Vamos agora reescrever o código do exemplo anterior utilizando uma sessão ao invés do cookie para armazenar o nome do usuário. Para isso, considere os seguintes códigos:

<!-- set_session.php -->
<?php
// Iniciando a sessão
session_start();

// Armazenando dados na sessão
$_SESSION['usuario'] = "maria123";

http_response_code(302);
header('Location: /');

<!-- index.php -->
<?php
// Iniciando a sessão
session_start();

// Verificando se o valor 'usuario' está definido na sessão
if(isset($_SESSION['usuario'])) {
    // Obtendo e exibindo o valor armazenado
    $usuario = $_SESSION['usuario'];
    echo "Bem-vind@, $usuario!";
} else {
    echo "Olá, visitante!"; // Caso o valor 'nome' não esteja definido na sessão
}
?>

Neste exemplo, considerando o mesmo ambiente do exemplo anterior, quando a primeira requisição for feita para http://localhost:8080 a função session_start() irá verificar que não existe um cookie contendo um session ID. Com isso, ela irá criar uma nova sessão, com seu session ID, e adicioná-lo no cabeçalho da resposta ao cliente. Ainda assim, a condição do if será falsa, pois a sessão (representada no PHP por um array associativo, guardado na variável superglobal $_SESSION) está vazia. Assim, a resposta será "Olá, visitante!", da mesma forma que antes, mas com uma diferença: desta vez há um cookie sendo setado automaticamente.

Quando o usuário acessar então http://localhost:8080/set_session.php, a função session_start() irá verificar que já existe um cookie de sessão (PHPSESSID) e irá carregar na superglobal $_SESSION os dados correspondentes (mas lembre-se que a sessão ainda está vazia). Logo a seguir, o código adiciona no índice "usuario" da sessão o valor "maria123", e redireciona o cliente para a index, da mesma forma que no exemplo anterior.

Agora, fazendo uma nova requisição para a URI /, a execução de session_start() em index.php irá fazer o mesmo que antes – verificar que existe um cookie de sessão e carregar a superglobal $_SESSION com os dados. Neste momento, entretando, o array carregado tem no índice "usuario" o valor "maria123". Com isso, a condição do if será verdadeira e o código prosseguirá normalmente.

A grade diferença aqui é que, enquanto no exemplo anterior o valor de "usuario" está salvo no cliente, neste exemplo este valor está salvo no servidor. Lembre-se que os dados armazenados no cliente são passíveis de leitura e modificação por parte dos usuários, o que significa que, no exemplo anterior, um usuário malicioso poderia deliberadamente trocar seu nome de usuário, mesmo tendo sido setado pelo servidor, já que este dado está salvo em um cookie. Neste segundo exemplo, o usuário apenas tem acesso a um session ID, que indicará ao servidor onde, no seu lado, os dados estão salvos. Dessa forma, mesmo um usuário malicioso não é capaz de modificar o que está no servidor, podendo no máximo fazer um ataque de roubo de sessão.

Conclusão

Cookies e sessões são fundamentais para permitir que as Aplicações Web mantenham informações de estado e identificação dos usuários. Enquanto os cookies são armazenados no navegador do usuário e permitem a personalização da experiência do usuário em várias páginas, as sessões oferecem uma abordagem mais segura, armazenando os dados do usuário no servidor. A escolha entre cookies e sessões depende das necessidades específicas da aplicação e do nível de segurança desejado.

Formulários HTML e PHP

Ranieri Valença — Wed, 26 Jul 2023 17:40:16 +0000

Tópicos

1. Introdução
2. Inputs e Interação com o Usuário
3. Inputs do Tipo "hidden"
4. Action e Métodos de Envio
5. Manipulação de Dados
5.1. Validação de Dados
6. Sanitização de Dados
7. Envio de Arquivos
8. Conclusão

Introdução

O HTML é uma linguagem de marcação amplamente utilizada para formatar documentos na web. Além de permitir a criação de estruturas de página e elementos visuais, o HTML também possibilita a criação de interações com os usuários por meio de âncoras (<a>) e formulários (<form>). Os formulários são elementos essenciais que permitem aos usuários inserir dados e enviar informações para os servidores web.

Diferentemente das âncoras usadas para criar links entre documentos, que geram requisições HTTP com o método GET quando clicadas, os formulários possibilitam a criação de requisições com diferentes métodos, como GET e POST. Ao submeter um formulário, o navegador envia uma requisição ao servidor contendo os dados inseridos nos campos do formulário.

Inputs e Interação com o Usuário

Os inputs são elementos fundamentais nos formulários HTML e representam os campos onde os usuários podem inserir dados. Cada input possui um atributo type, que define o tipo de dado que será inserido no campo. Os tipos mais comuns de input são:

text: Permite a inserção de texto simples.
password: Semelhante ao text, mas mascara os caracteres digitados, útil para senhas.
number: Aceita apenas números, com opção de definir um intervalo válido.
email: Projetado especificamente para inserção de endereços de e-mail válidos. Muito útil na criação de interfaces mobile-first.
checkbox: Representa uma caixa de seleção que permite ao usuário marcar uma ou várias opções.
radio: Representa um botão de opção que permite ao usuário selecionar apenas uma opção de um grupo.

Além desses inputs, há também os elementos <select> que cria um menu suspenso (drop-down) com opções selecionáveis e <textarea>que permite a inserção de texto longo em várias linhas.

Para entender melhor os atributos e a utilização dos inputs, recomenda-se consultar a documentação do W3Schools sobre HTML Input Types e o guia da MDN sobre Formulários HTML.

Inputs do Tipo "hidden"

Além dos inputs mencionados anteriormente, existe o tipo de input "hidden". Esse tipo de input é invisível para o usuário, não sendo exibido na interface da página. Ele é frequentemente utilizado para armazenar dados importantes que precisam ser enviados ao servidor, mas que não necessitam da interação direta do usuário.

Os inputs do tipo "hidden" são particularmente úteis para o envio de informações de controle, como identificadores únicos, valores padrão ou tokens que precisam ser processados no lado do servidor. Por exemplo, ao enviar um formulário de edição de um item, pode-se incluir um input do tipo "hidden" para armazenar o ID do item que está sendo editado.

<input type="hidden" name="id" value="123">

Action e Métodos de Envio

Os formulários em HTML oferecem a flexibilidade de escolher o método de envio para a requisição HTTP. O método padrão é o GET, que envia os dados como parte da URI da requisição. Essa abordagem é mais adequada para formulários que não contêm dados sensíveis e não realizam ações que possam modificar informações no servidor. Por exemplo, um formulário de busca que utiliza o método GET pode enviar os parâmetros de pesquisa na URI, permitindo que o usuário compartilhe facilmente a URL com os resultados da busca.

Por outro lado, o método POST envia os dados como parte do corpo da requisição, tornando-os invisíveis na URI. Isso é particularmente útil para formulários que contêm informações confidenciais ou que executam ações que podem alterar o estado do servidor, como adicionar, editar ou excluir dados. Por exemplo, um formulário de cadastro de usuário ou de envio de informações pessoais deve utilizar o método POST para proteger a privacidade dos dados do usuário.

Quando um formulário é submetido, o request é feito para o endereço apontado pelo atributo action:

<form action="/update.php" method="POST">
  ...
  <input type="submit">
</form>

Neste exemplo, quando o formulário for submetido será feita uma requisição utilizando o método POST para a URI /update.php. Em formulário sem o atributo action, a requisição é feita para a própria URI onde o usuário está.

Para saber mais sobre os métodos de envio em formulários HTML, você pode consultar a documentação do W3Schools sobre HTML Forms e a referência da MDN sobre Formulários HTML.

Manipulação de Dados

Ao enviar um formulário, os dados inseridos pelo usuário são enviados ao servidor. Cada linguagem terá sua forma de lidar com estes dados. O PHP fornece uma série de variáveis superglobais, como $_GET, $_POST e $_REQUEST, que contêm os dados enviados pelo formulário e podem ser acessados para processamento posterior. Por exemplo, se o formulário possui um campo com o nome "idade" (<input type="text" name="idade">), é possível acessar o valor desse campo no lado do servidor através de $_POST['idade'] caso o método de envio seja POST, ou $_GET['idade'] caso o método seja GET. Note que o valor do atributo name do <input> é o índice na variável superglobal, e esse índice é case sensitive (sensível ao caso – maiúsculas e minúsculas importam).

Para entender melhor como manipular os dados de um formulário no lado do servidor com PHP, você pode consultar a documentação do W3Schools sobre PHP Form Handling, a referência da MDN sobre Manipulação de Dados de Formulários HTML ou a referência do manual do PHP Tratando formulários.

Validação de Dados

A validação de dados é uma etapa crucial no processamento de formulários. É importante garantir que os dados recebidos do usuário estejam corretos e se encaixem nos critérios esperados antes de serem usados. A validação pode incluir a verificação de campos obrigatórios, o formato correto de endereços de e-mail, números ou datas e outros critérios específicos para os dados inseridos. A validação pode (e deve) ser feita tanto no lado do cliente (assegurando uma melhor experiência para os usuários) quanto no lado do servidor, garantindo a segurança.

O PHP oferece funções e recursos para facilitar a validação de dados. Os desenvolvedores podem utilizar funções como filter_var() e expressões regulares para verificar e validar os dados antes de processá-los. Por exemplo, é possível usar filter_var($_POST['email'], FILTER_VALIDATE_EMAIL) para verificar se o campo de e-mail possui um formato válido.

Para aprofundar seus conhecimentos em validação de dados tanto no front-end quando com PHP, você pode consultar a documentação do W3Schools sobre PHP Filters e a referência da MDN sobre Client-side Form Validation.

Sanitização de Dados

Além da validação, a sanitização de dados é outra etapa importante no processamento dos dados recebidos pelo formulário. A sanitização envolve a remoção de caracteres perigosos, como tags HTML, scripts maliciosos e outras entradas indesejadas, para evitar vulnerabilidades de segurança, como ataques de injeção de código.

O PHP fornece funções como filter_input() e htmlspecialchars() que podem ser utilizadas para sanitizar os dados recebidos do formulário antes de serem utilizados em operações críticas. A função htmlspecialchars() converte caracteres especiais em entidades HTML, garantindo que eles sejam interpretados como texto e não como código executável.

Para entender a importância do processo de sanitização, você pode acessar a página sobre XSS na Wikipedia ou no MDN

Envio de Arquivos

Em alguns casos, os formulários precisam permitir que os usuários enviem arquivos para o servidor, como imagens, documentos ou vídeos. Para lidar com esse tipo de formulário, é necessário adicionar o atributo enctype="multipart/form-data" à tag <form> associada com o method="POST". Esse atributo indica ao navegador que o formulário contém arquivos binários a serem enviados, o que altera a forma como o pacote da requisição HTTP é construído.

Por exemplo, considere o seguinte formulário:

<form action="http://exemplo.com/upload" method="post" enctype="multipart/form-data">
  <label for="nome">Nome:</label>
  <input type="text" id="nome" name="nome">

  <label for="arquivo">Enviar Arquivo:</label>
  <input type="file" id="arquivo" name="arquivo">

  <input type="submit" value="Enviar">
</form>

Ao ser submetido com um arquivo chamado "example.txt", o pacote HTTP seria algo similar ao seguinte:

POST /upload HTTP/1.1
Host: exemplo.com
Content-Type: multipart/form-data; boundary=----WebKitFormBoundary7MA4YWxkTrZu0gW

------WebKitFormBoundary7MA4YWxkTrZu0gW
Content-Disposition: form-data; name="nome"

John Doe
------WebKitFormBoundary7MA4YWxkTrZu0gW
Content-Disposition: form-data; name="arquivo"; filename="example.txt"
Content-Type: text/plain

... conteúdo do arquivo example.txt ...
------WebKitFormBoundary7MA4YWxkTrZu0gW--

Do lado do PHP, o tratamento dos arquivos enviados é feito através de variáveis superglobais especiais, como $_FILES, que contém informações sobre o arquivo, como o nome original, o tipo MIME e o local temporário onde o arquivo é armazenado. Os desenvolvedores podem mover e manipular esses arquivos usando as funções apropriadas do PHP, como move_uploaded_file() para salvar o arquivo em um local permanente no servidor.

Conclusão

Ao utilizar formulários HTML em conjunto com o PHP, os desenvolvedores podem criar interações entre os usuários e as aplicações web. Os métodos de envio, a manipulação, validação e sanitização de dados, bem como o envio de arquivos, são fundamentais para o funcionamento seguro e eficiente dos formulários web. Ao entender esses conceitos e utilizar as ferramentas disponíveis no PHP, é possível criar formulários robustos e confiáveis que proporcionam uma ótima experiência aos usuários.

Servidores e Clientes Web

Ranieri Valença — Wed, 26 Jul 2023 11:47:16 +0000

Tópicos

1. Introdução
2. Servidores Web
3. Apache e Nginx
       3.1. Servidores Web e PHP
       3.2. Diretório Raiz, / e Index
             a. Diretório Raiz
             b. / (Barra)
             c. Index
4. O servidor embutido do PHP
       4.1. Utilizando o servidor embutido
5. Clientes Web

Introdução

No universo do desenvolvimento de aplicações web, os termos "servidor" e "cliente" ganham uma conotação específica e essencialmente relacionada ao mundo dos softwares. Diferente da imagem tradicional de salas repletas de racks de computadores, quando se fala em servidores no contexto web, estamos nos referindo a programas de computador cuja função primordial é receber, processar e responder a requisições feitas por clientes. Enquanto isso, os clientes, igualmente, são softwares projetados para conectar-se a esses servidores, enviando requisições e processando as respostas obtidas.

Nesse cenário, a arquitetura cliente-servidor surge como a base do funcionamento de aplicações web, permitindo a interação entre dispositivos conectados à internet. Enquanto os servidores, como o Apache e o Nginx, executando em computadores remotos (às vezes realmente em salas cheias de racks de computadores) atuam como os anfitriões que disponibilizam serviços e recursos, os clientes, representados por navegadores (browsers), Postman, Insomnia e outros atuam como os agentes requisitantes, permitindo que os usuários interajam com páginas, APIs e outros serviços disponíveis na web.

Neste artigo, exploraremos algumas características de servidores Web e de alguns dos principais servidores web, como o Apache e o Nginx, destacando suas características e usos mais comuns no desenvolvimento de aplicações web. Além disso, abordaremos o servidor embutido do PHP, que oferece uma maneira conveniente para os desenvolvedores testarem suas aplicações localmente antes da implantação em ambientes de produção.

Também analisaremos a importância dos clientes web e as diversas ferramentas disponíveis, como os navegadores populares que utilizamos diariamente para navegar pela web, bem como aplicações especializadas, como o Postman e o Insomnia, que oferecem recursos específicos para desenvolvimento e teste de APIs.

Servidores Web

Um conceito essencial no funcionamento dos servidores é que, na sua essência, todo servidor é um software que "escuta" em uma porta específica, seja ela TCP ou UDP. Essa "escuta" é o que permite que os servidores recebam requisições provenientes de clientes, como navegadores web ou outras aplicações. Quando um servidor é iniciado, ele escolhe uma porta específica em que deseja "escutar". As portas mais baixas (0 a 1023) são conhecidas como "well-known ports" e são geralmente reservadas para serviços amplamente utilizados, como HTTP (porta 80), HTTPS (porta 443), FTP (porta 21), entre outros.

Quando um cliente deseja se comunicar com o servidor, ele precisa conhecer o endereço IP e o número da porta em que o servidor está escutando. Com essas informações em mãos, o cliente pode estabelecer uma conexão com o servidor e através dela enviar uma requisições e aguardar pelas respostas. Os detalhes de como esta conexão acontece dizem respeito à API de socket do sistema operacional, mas não serão abordados neste artigo.

Essa ideia de "escutar" em uma porta e estabelecer conexões com base nas requisições recebidas é o que permite que os servidores web, como o Apache e o Nginx, atendam a múltiplos clientes simultaneamente. Cada nova requisição recebida resulta na criação de uma nova conexão, permitindo que o servidor processe várias requisições de diferentes clientes de forma concorrente.

Apache e Nginx

O Apache HTTP Server e o Nginx são dois dos servidores web mais populares e amplamente utilizados na Internet. O Apache é conhecido por sua flexibilidade e extensibilidade, permitindo que os desenvolvedores personalizem e expandam suas funcionalidades através de módulos. Ele suporta várias plataformas, incluindo Linux, Windows, macOS e outras.

Por outro lado, o Nginx (pronuncia-se "engine-x") é um servidor web de alto desempenho e também atua como servidor proxy reverso e proxy HTTP. Ele ganhou destaque por sua capacidade de lidar com grandes cargas de tráfego de forma eficiente e escalável, sendo amplamente utilizado em configurações de alto volume.

Ambos os servidores têm como função principal "escutar" as requisições HTTP ou HTTPS (caso o protocolo TLS esteja habilitado) recebidas de clientes, como navegadores web, e repassá-las aos softwares que de fato realizarão o processamento da requisição. Esses softwares podem ser aplicações web escritas em diversas linguagens de programação, como PHP, Python, Ruby, Node.js, entre outras. Ao receber a resposta dessas aplicações, o servidor web a envia de volta ao cliente que fez a requisição, permitindo que o conteúdo dinâmico das páginas web seja exibido ao usuário.

Uma das características importantes do Apache e do Nginx é a capacidade de atuarem como proxies. Um proxy é um intermediário que recebe as requisições de clientes e as encaminha para outros servidores, na mesma máquina ou em máquinas remotas. Esse recurso é valioso para arquiteturas distribuídas, em que várias aplicações podem estar sendo executadas em diferentes servidores e o servidor web atua como um ponto de entrada único para os clientes.

Além disso, os servidores web também desempenham um papel importante na implementação de recursos de segurança, como autenticação de usuário, autorização de acesso e criptografia através do protocolo HTTPS. Eles permitem que os administradores de sistemas configurem regras de segurança e protejam as aplicações contra ameaças e ataques cibernéticos.

Servidores Web e PHP

No caso específico de aplicações escritas em PHP, o Apache e o Nginx se comunicam com um intermediário conhecido como "PHP-FPM" (PHP FastCGI Process Manager). O PHP-FPM é um gerenciador de processos PHP que atua como um "caller" intermediário entre o servidor web e a aplicação PHP. Quando uma requisição é recebida pelo servidor web e destina-se a uma aplicação PHP, o PHP-FPM é acionado. Internamente, o PHP-FPM realiza o equivalente a uma chamada ao script PHP em questão como se fosse feita no terminal. Esse processo permite que o PHP-FPM execute a aplicação PHP e retorne o resultado ao servidor web, que por sua vez enviará a resposta ao cliente que fez a requisição.

Essa arquitetura com o PHP-FPM traz benefícios significativos para o desempenho e a escalabilidade das aplicações PHP. Como o PHP-FPM é capaz de gerenciar processos PHP separados do servidor web, ele permite um controle mais eficiente e otimizado dos recursos do servidor. Além disso, ele pode gerenciar múltiplos processos PHP simultaneamente, o que melhora o desempenho e a capacidade de resposta das aplicações em situações de alta demanda de tráfego.

Diretório Raiz, `/` e Index

Quando um servidor web recebe uma requisição HTTP de um cliente para uma determinada URI, ele precisa determinar qual arquivo ou recurso corresponde a essa URI. Em muitos casos, a URI solicitada corresponde a um diretório no sistema de arquivos do servidor web.

Diretório Raiz

O diretório raiz, também conhecido como "Document Root" ou "Root Directory", é o ponto de partida para o servidor web ao atender uma requisição. Quando o servidor recebe uma URI, ele busca o arquivo correspondente a partir do diretório raiz.

Em servidores web como o Apache e o Nginx, o diretório raiz é configurado no arquivo de configuração do servidor, como o arquivo httpd.conf para o Apache. É nessa configuração que os administradores do servidor definem qual diretório no sistema de arquivos deve ser considerado como diretório raiz para atender as requisições HTTP.

Por exemplo, se o diretório raiz estiver configurado como /var/www/html, todas as requisições serão tratadas a partir desse diretório como ponto de partida. Se o cliente solicitar a URI /pagina.html, o servidor procurará o arquivo pagina.html dentro do diretório raiz (/var/www/html/pagina.html) para responder à requisição.

`/` (Barra)

A barra (/) é um caractere especial utilizado na URI para representar o diretório raiz. Quando um cliente solicita a URI /, ele está pedindo o recurso raiz do servidor web. Nesse caso, o servidor procura pelo arquivo específico que representa a página inicial padrão do diretório raiz. Esta é a URI padrão que é requisitada quando o usuário digita apenas o domínio, como www.exemplo.com. Nesse caso, o cliente fará uma requisição para o servidor deste domínio passando a URI / em seu pacote HTTP.

Index

O "index" é um nome de arquivo padrão utilizado pelos servidores web para identificar a página inicial de um diretório. Quando o servidor recebe uma requisição para uma URI que termina com /, ou seja, representa o diretório raiz, ele procura automaticamente por um arquivo chamado index dentro desse diretório.

A extensão do arquivo index pode variar dependendo da linguagem de programação ou tecnologia utilizada. As extensões mais comuns são .html e .php, mas também podem ser .htm, .xhtml, .asp, entre outras, dependendo da configuração do servidor e do tipo de aplicação web.

Por exemplo, com uma certa configuração do servidor, se um cliente solicitar a URI /, o servidor procurará pelos seguintes arquivos (nessa ordem) para responder à requisição:

index.html
index.php
Outros arquivos index definidos no servidor

Caso encontre um desses arquivos no diretório raiz, o servidor o utilizará como resposta à requisição, exibindo-o no navegador do cliente. Se nenhum desses arquivos estiver presente, o servidor retornará uma resposta com código 404 (Not Found).

Portanto, quando um desenvolvedor configura corretamente o servidor web e coloca um arquivo index.[html|php|asp|...] no diretório raiz, o cliente poderá acessar o site apenas digitando o domínio ou endereço IP do servidor, sem a necessidade de digitar o nome do arquivo na URI. Isso é especialmente comum em sites que utilizam tecnologias de desenvolvimento web como PHP, onde o arquivo index.php frequentemente funciona como a página inicial de um site ou aplicação web.

O servidor embutido do PHP

O servidor embutido do PHP é uma ferramenta extremamente útil para o desenvolvimento e teste de aplicações em PHP. Ele oferece uma forma simples e rápida de iniciar um servidor web local diretamente a partir da linha de comando, sem a necessidade de configurar e executar um servidor web externo, como o Apache ou o Nginx.

Internamente, o servidor embutido do PHP inicia um servidor HTTP, que escuta na porta especificada pelo desenvolvedor. Ao receber uma requisição, ele executa diretamente o arquivo solicitado, caso seja um arquivo PHP. Nesse caso, o servidor embutido interpreta o código PHP contido no arquivo e retorna o resultado para o cliente que fez a requisição.

Essa abordagem simplificada torna o desenvolvimento mais ágil, pois não requer a configuração adicional do PHP-FPM nem a necessidade de ter outro servidor web em execução. É uma solução prática para desenvolvedores que desejam criar e testar aplicações PHP localmente de forma rápida e sem complicações.

Entretanto, é importante ressaltar que o servidor embutido do PHP não foi projetado para uso em ambientes de produção. Ele não oferece o mesmo nível de desempenho e escalabilidade que servidores web como o Apache ou o Nginx podem proporcionar. Sua finalidade é facilitar o desenvolvimento e o teste local, permitindo que os desenvolvedores executem suas aplicações rapidamente sem a necessidade de configurações complexas.

Uma característica interessante do servidor embutido é a utilização de um script de "roteamento" (também conhecido como Front Controller). Todas as requisições que chegam são enviadas para este único script, que é responsável por fazer o processamento e enviar a resposta para o cliente. Isso permite que a aplicação utilize URLs amigáveis, que são URLs mais legíveis e significativas para os usuários, sem a presença de extensões de arquivos ou parâmetros complexos.

Com a utilização do Front Controller, o servidor embutido pode direcionar cada requisição para a parte apropriada da aplicação, facilitando a organização e a estrutura do código. Essa abordagem também permite a implementação de rotas personalizadas e o uso de frameworks PHP populares, como o Laravel, o Symfony e o CodeIgniter.

Para utilizar o servidor embutido do PHP, tendo o PHP instalado e disponível no PATH do terminal de comando, é preciso navegar até um diretório, que será considerado o diretório raiz, e digitar o seguinte comando:

Utilizando o servidor embutido

php -S localhost:8000

Neste exemplo, estamos informando ao servidor embutido que ele deve escutar requisições vindas de localhost (ou seja, do próprio computador) na porta 8000. A porta pode ser escolhida conforme o gosto do usuário, e também é possível trocar o localhost por 0.0.0.0, fazendo com o que o servidor escute requisições vindas de qualquer cliente conectado na mesma rede que o computador (embora possivelmente seja necessário fazer configurações no firewall para permitir esse tipo de uso).

Sem o PHP instalado também é possível fazê-lo utilizando Docker. Falaremos mais sobre esta plataforma em outros artigos, mas a ideia é utilizar um container com uma imagem do PHP, fazê-lo iniciar o servidor embutido do PHP em um dado diretório e montar o diretório local neste diretório do container:

docker run --rm -v $(pwd):/app -w /app -p 8080:8080 php:8.2 php -S 0.0.0.0:8080

docker run --rm -v %cd%:/app -w /app -p 8080:8080 php:8.2 php -S 0.0.0.0:8080

usando o terminal nativo do Windows.

Clientes Web

Clientes web desempenham um papel crucial no ecossistema da internet e são fundamentais para a comunicação entre os usuários e os servidores web que hospedam as aplicações. Embora os navegadores (browsers) sejam os clientes web mais conhecidos e amplamente utilizados, é importante destacar que a categoria de clientes web abrange uma ampla gama de aplicações que se conectam a servidores por meio do protocolo HTTP ou HTTPS.

Os navegadores modernos, como Google Chrome, Mozilla Firefox, Microsoft Edge e Safari, são verdadeiras plataformas de software sofisticadas, comportando-se quase como sistemas operacionais. Eles incorporam diversos módulos e funcionalidades que trabalham em conjunto. Esses módulos incluem acesso à rede para estabelecer conexões com servidores web, mecanismos de parsing para interpretar e processar os códigos HTML e CSS, renderização para exibir as páginas web, tratamento de eventos para lidar com ações do usuário, motor de JavaScript para executar código do lado do cliente e muito mais.

Os navegadores são capazes de enviar diferentes tipos de requisições HTTP aos servidores, como GET, POST, PUT, DELETE, entre outras utilizando apenas suas APIs nativas. Essas requisições podem conter cabeçalhos personalizados, cookies e outras informações relevantes para a comunicação com os servidores. Além disso, os navegadores têm a capacidade de lidar com diversos formatos de resposta enviados pelos servidores, como documentos HTML, XML, JSON e também arquivos binários, como imagens e vídeos.

No entanto, além dos navegadores, existem outras aplicações que também funcionam como clientes web. As aplicações mobile, por exemplo, são projetadas para dispositivos móveis, como smartphones e tablets, e têm a capacidade de criar suas próprias requisições HTTP com cabeçalhos personalizados e enviar dados binários para os servidores com os quais se conectam. Isso abre um leque gigantesco de possibilidades para desenvolver aplicativos móveis que interagem com serviços e recursos disponíveis na web.

Além disso, com o advento da Internet das Coisas (IoT), dispositivos inteligentes, como smartwatches, termostatos inteligentes, câmeras e outros gadgets conectados à internet, também podem atuar como clientes web, enviando e recebendo dados de servidores remotos para oferecer uma experiência conectada aos usuários.

Outras ferramentas essenciais no universo do desenvolvimento de aplicações web são o Postman, o Insomnia, o Thunder Client (extensão do VSCode) e outros similares. Esses clientes web são projetados especificamente para desenvolvedores, permitindo que eles criem e testem requisições HTTP de forma rápida e eficiente. Essas ferramentas possuem interfaces que permitem aos desenvolvedores configurar várias opções, como parâmetros, cabeçalhos personalizados, autenticação e muito mais. Com esses clientes, os desenvolvedores podem realizar testes de integração, testes de API e verificar as respostas dos servidores para garantir que suas aplicações estejam funcionando corretamente.

Com este artigo eu espero que fique mais claro que são servidores e clientes web, quais seus papeis e como utilizar o servidor embutido do PHP para começar a desenvolver Aplicações Web.

A arquitetura Cliente-Servidor e o protocolo HTTP

Ranieri Valença — Tue, 25 Jul 2023 19:04:41 +0000

Tópicos

1. Tópicos
2. Protocolo HTTP
       2.1. Stateless
       2.2. Estrutura
       2.3. Requisições HTTP
             a. GET
             b. POST
             c. PUT
             d. DELETE
       2.4. Respostas HTTP
             a. JSON
             b. XML
             c. HTML
       2.5. Arquivos
3. MIME-Type em Responses
4. URI vs. URL
5. Bônus - o cliente Curl: Uma Ferramenta Versátil para Requisições HTTP
       5.1. Exemplos de Uso do Curl:
6. Conclusão

Introdução

Partindo do princípio que o leitor tem noções gerais de rede de computadores e conhecimento sobre a comunicação entre dispositivos através das redes e sabe o que é um protocolo de comunicação, este artigo trata sobre a arquitetura cliente-servidor e o protocolo HTTP.

A arquitetura cliente-servidor é um modelo de comunicação muito utilizado em sistemas distribuídos e aplicações web. Nesse modelo, o sistema é dividido em duas partes principais: o cliente e o servidor. O cliente é responsável por fazer solicitações ao servidor e processar as respostas recebidas. Já o servidor é responsável por receber as solicitações do cliente, processá-las e enviar as respostas de volta ao cliente.

A comunicação entre o cliente e o servidor na Web é geralmente realizada através do protocolo HTTP (Hypertext Transfer Protocol), que é amplamente utilizado na internet para a transferência de dados entre clientes e servidores.

Protocolo HTTP

O protocolo HTTP é baseado no modelo requisição-resposta, onde o cliente envia uma requisição ao servidor e o servidor responde com os dados solicitados ou um código de status indicando o resultado da operação.

É um protocolo baseado em texto (apesar de poder transportar dados binários) e utiliza o TCP (Transmission Control Protocol) como protocolo de transporte. O TCP é um dos principais protocolos da camada de transporte do modelo TCP/IP e é responsável por garantir uma comunicação confiável entre os dispositivos.

Ao utilizar o TCP como protocolo de transporte, o HTTP pode contar com mecanismos como confirmações de recebimento (ACKs), retransmissão de pacotes perdidos e controle de fluxo para garantir que os dados sejam entregues de forma confiável e em ordem.

O uso do TCP torna o HTTP uma escolha robusta para a transferência de dados na internet, especialmente para aplicações que exigem alta confiabilidade e precisão na entrega de informações.

Stateless

O protocolo HTTP (Hypertext Transfer Protocol) é considerado stateless, o que significa que cada requisição enviada pelo cliente ao servidor é tratada de forma independente e não contém informações sobre ações anteriores. Em outras palavras, o servidor não mantém informações sobre o estado da sessão ou interação com o cliente entre as requisições.

Algumas informações importantes sobre protocolos stateless:

Cada requisição é tratada de forma independente.
Não há armazenamento de informações de estado entre requisições.
O servidor não mantém informações sobre as ações anteriores do cliente.
A comunicação é mais simples e leve, pois não há necessidade de manter uma conexão contínua entre o cliente e o servidor.
É mais escalável, pois cada requisição pode ser processada de forma isolada e distribuída entre diferentes servidores.

Essa natureza stateless do HTTP tem implicações importantes para o desenvolvimento de aplicações web. Como o servidor não mantém informações sobre o estado da sessão, todas as informações relevantes devem ser incluídas na própria requisição, geralmente através de cabeçalhos ou parâmetros na URL. Isso permite que o servidor trate cada solicitação de forma independente, tornando a comunicação mais simples e previsível.

Por outro lado, aplicações que exigem uma comunicação mais complexa e interativa, como sistemas de autenticação ou carrinhos de compras em e-commerce, podem enfrentar desafios adicionais ao trabalhar com o HTTP stateless. Nesses casos, podem ser necessárias técnicas adicionais, como o uso de cookies ou tokens, para manter informações de estado entre as requisições. Falaremos sobre isso em outros artigos futuros.

Estrutura

Uma requisição HTTP consiste em uma série de linhas de texto, separadas por \n, que delimita uma linha. A requisição tem uma linha inicial contendo o método da requisição, o caminho do recurso desejado e a versão do protocolo, seguida por cabeçalhos opcionais e o corpo da requisição (opcional em algumas situações).

Exemplo de uma requisição HTTP:

GET /pagina.html HTTP/1.1
Host: www.exemplo.com
User-Agent: Mozilla/5.0

Uma resposta HTTP também consiste em uma linha inicial contendo a versão do protocolo, o código de status e uma frase descritiva, seguida por cabeçalhos opcionais e o corpo da resposta (opcional em algumas situações).

Exemplo de uma resposta HTTP:

HTTP/1.1 200 OK
Content-Type: text/html
Content-Length: 1234

<html>
<head>
<title>Página de Exemplo</title>
</head>
<body>
...
</body>
</html>

Os cabeçalhos do protocolo HTTP são bastante numerosos, além de poderem ser definidos pela aplicação (ou seja, uma aplicação pode adicionar cabeçalhos não-padrões), tanto na requisição quanto na resposta. Para mais informações sobre os cabeçalhos http, vale dar uma olhada na página de cabeçalhos do HTTP do MDN Web Docs

A seguir, vamos detalhar um pouco mais a requisição (request) e a resposta (response) de mensagens deste protocolo.

Requisições HTTP

As requisições HTTP são a base da interação entre cliente e servidor na arquitetura cliente-servidor. Cada requisição é composta por um método, um caminho (URI – falaremos mais adiante sobre URI e URL) e uma versão do protocolo – esta é a primeira linha da requisição. Além disso, as requisições podem incluir cabeçalhos e um corpo com dados adicionais.

A definição do protocolo HTTP em sua versão mais usada atualmente (1.1) é feita na RFC 2616 (um documento que vale muito a leitura) e define os seguintes métodos para o HTTP:

OPTIONS
GET
HEAD
POST
PUT
DELETE
TRACE
CONNECT

Apesar disso, alguns métodos são mais utilizados e serão explicados melhor a seguir.

GET

O método GET é usado para solicitar a recuperação de um recurso específico no servidor. Ele envia os parâmetros na URL, geralmente na forma de cadeias de consulta (query strings). Este é o método mais utilizado na Web, pois é com ele que os browsers fazem a requisição para os servidores.

Exemplo de requisição GET:

GET /pagina.html?parametro1=valor1&parametro2=valor2 HTTP/1.1
Host: www.exemplo.com

Neste exemplo, apenas um cabeçalho extra está sendo enviado (Host: www.exemplo.com), a URI é /pagina.html e os parâmetros, enviados após o sinal de interrogação (?) são parametro1=valor1 e parametro2=valor2. Note também que, por ser uma requisição que utiliza o método GET, não há uma linha em branco após os cabeçalhos, já que este método não suporta um corpo adicional.

POST

O método POST é usado para enviar dados ao servidor, geralmente para criar um novo recurso ou enviar informações sensíveis, como senhas ou dados de formulários.

Exemplo de requisição POST:

POST /criar_usuario HTTP/1.1
Host: www.exemplo.com
Content-Type: application/x-www-form-urlencoded
Content-Length: 27

nome=João&email=joao@example.com

Neste exemplo, alguns cabeçalhos extras estão sendo incluídos (Host: www.exemplo.com, Content-Type: application/x-www-form-urlencoded e Content-Length: 27). Note que após os cabeçalhos há uma linha em branco (ou seja, duas quebras de linha seguidas – \n\n). Esta linha indica ao servidor que receberá esta requisição que o cabeçalho do protocolo está terminado, e que todo dado que ainda for enviado fará parte do corpo. O cabeçalho Content-Length indica quantos bytes o servidor deve esperar no corpo.

PUT

O método PUT é usado para enviar dados ao servidor para criar ou atualizar um recurso específico.

Exemplo de requisição PUT:

PUT /atualizar_usuario/123 HTTP/1.1
Host: www.exemplo.com
Content-Type: application/json
Content-Length: 47

{"nome": "Maria", "email": "maria@example.com"}

Neste exemplo, o tipo cabeçalho Content-Type avisa ao servidor que os dados enviados estão no formato application/json, e por conta disso é possível notar que o corpo da requisição contém dados em JSON (formato que será mais explorado adiante).

DELETE

O método DELETE é usado para solicitar a exclusão de um recurso específico no servidor.

Exemplo de requisição DELETE:

DELETE /excluir_usuario/456 HTTP/1.1
Host: www.exemplo.com

Respostas HTTP

As respostas HTTP são enviadas pelo servidor como resposta às requisições feitas pelo cliente. Cada resposta é composta por uma linha inicial contendo o código de status e a versão do protocolo, seguida pelos cabeçalhos e o corpo com os dados solicitados (se aplicável).

Os códigos de status são usados para indicar o resultado da requisição. Eles são divididos em classes numéricas que indicam o tipo de resposta. Alguns dos códigos de status mais comuns são:

2xx: Indica que a requisição foi bem sucedida, como por exemplo "OK" (200) ou "Created" (201).
3xx: Indica redirecionamento, como por exemplo "Found" (302).
4xx: Indica erros do cliente, como por exemplo "Not Found" (404) ou "Unauthorized" (401).
5xx: Indica erros no servidor, como por exemplo "Internal Server Error" (500).

O conteúdo das respostas podem ser de diversos tipos. A seguir, vamos falar um pouco sobre os mais comuns em aplicações web mais simples.

JSON

O JSON (JavaScript Object Notation) é um formato leve e amplamente utilizado para troca de dados entre cliente e servidor. Ele é fácil de ler e escrever para humanos e fácil de analisar e gerar para máquinas. Sua especificação pode ser acessada no site oficial, json.org.

Exemplo de resposta com JSON:

HTTP/1.1 200 OK
Content-Type: application/json
Content-Length: 56

{"nome": "João", "idade": 30, "email": "joao@example.com"}

Note que na resposta, após a linha inicial da resposta, existem alguns cabeçalhos (Content-Type: application/json e Content-Length: 56), e logo após uma linha em branco. Assim como na requisição, esta linha em branco indica ao cliente que está recebendo a resposta que acabaram os cabeçalhos, e que o que vem a seguir é o conteúdo (corpo) da resposta.

XML

O XML (eXtensible Markup Language) é outra opção para troca de dados entre cliente e servidor. Ele é mais verboso que o JSON, mas também é amplamente suportado e estruturado.

Exemplo de resposta com XML:

HTTP/1.1 200 OK
Content-Type: application/xml
Content-Length: 143

<usuario>
    <nome>João</nome>
    <idade>30</idade>
    <email>joao@example.com</email>
</usuario>

HTML

O HTML é usado para definir a estrutura e o layout de páginas web. As respostas HTML são renderizadas pelos navegadores para exibir conteúdo aos usuários.

Exemplo de resposta com HTML:

HTTP/1.1 200 OK
Content-Type: text/html
Content-Length: 1234

<!DOCTYPE html>
<html>
<head>
    <title>Página de Exemplo</title>
</head>
<body>
    <h1>Olá, mundo!</h1>
</body>
</html>

Arquivos

As respostas também podem conter arquivos binários, como imagens, vídeos, documentos, etc. Nesses casos, o servidor define o cabeçalho Content-Type apropriado para indicar o tipo de arquivo.

Exemplo de resposta com arquivo:

HTTP/1.1 200 OK
Content-Type: image/jpeg
Content-Length: 45678

<dados binários do arquivo>

Neste exemplo, o Content-Type do cabeçalho está informando ao cliente que o corpo da resposta tem os dados binários de uma imagem no formato JPG. Considerando a importância de conhecer este cabeçalho, vamos falar um pouco mais sobre ele.

MIME-Type em Responses

O MIME-Type (Multipurpose Internet Mail Extensions) é um tipo de dado que indica o formato e o tipo de conteúdo presente em uma resposta HTTP. Ele é especificado através do cabeçalho Content-Type. O MIME-Type é essencial para que o cliente saiba como interpretar e processar o conteúdo da resposta corretamente.

Por exemplo, o Content-Type pode ser definido como application/json para indicar que a resposta contém dados no formato JSON, ou como text/html para indicar que a resposta é uma página HTML, ou text/css para indicar que a resposta trata-se de um arquivo de folha de estilos CSS.

Você pode encontrar mais informações sobre os diferentes tipos de MIME-Type no MDN Web Docs.

URI vs. URL

URI (Uniform Resource Identifier) e URL (Uniform Resource Locator) são conceitos relacionados, mas não idênticos.

Uma URI é uma sequência compacta de caracteres que identifica um recurso abstrato ou físico, que pode ser um documento, imagem, serviço, etc. A URI é uma terminologia genérica que inclui URLs e URNs (Uniform Resource Names).

Uma URL é um tipo específico de URI que fornece os meios para localizar um recurso através de sua representação como uma sequência de caracteres. A URL inclui o esquema (como HTTP ou FTP), o domínio ou endereço IP, a porta, o caminho e os parâmetros.

Em resumo, toda URL é uma URI, mas nem toda URI é uma URL. Por exemplo, a URI urn:isbn:0451450523 identifica unicamente um livro pelo seu número ISBN, mas não é uma URL, pois não indica como acessar o recurso.

Para mais informações sobre URI e URL, você pode consultar o artigo da Wikipedia.

Bônus - o cliente Curl: Uma Ferramenta Versátil para Requisições HTTP

O curl é uma ferramenta de linha de comando amplamente utilizada para fazer requisições HTTP e interagir com diversos tipos de serviços na web. Com ele, é possível realizar operações como enviar dados para APIs, realizar testes de conectividade e até mesmo baixar arquivos. A versatilidade e simplicidade do curl o tornam uma escolha popular entre desenvolvedores e administradores de sistemas.

Exemplos de Uso do Curl:

Requisição GET para uma API de Teste: JSONPlaceholder

A JSONPlaceholder é uma API de teste que fornece dados fictícios em formato JSON para fins de desenvolvimento e teste. Vamos usar o curl para fazer uma requisição GET para a rota "/users/1" e obter os dados do usuário com id 1.

curl https://jsonplaceholder.typicode.com/users/1

Podemos também adicionar o argumento -v para que o Curl exiba também os cabeçalhos, tanto do request quanto do response:

curl -v https://jsonplaceholder.typicode.com/users/1

Nesse caso, a resposta será algo como

> GET /users/1 HTTP/2
> Host: jsonplaceholder.typicode.com
> user-agent: curl/7.88.1
> accept: */*
> 
< HTTP/2 200 
< date: Tue, 25 Jul 2023 18:29:21 GMT
< content-type: application/json; charset=utf-8
< content-length: 509
< x-powered-by: Express
< x-ratelimit-limit: 1000
< x-ratelimit-remaining: 998
< x-ratelimit-reset: 1689692921
< vary: Origin, Accept-Encoding
< access-control-allow-credentials: true
< cache-control: max-age=43200
< pragma: no-cache
< expires: -1
< x-content-type-options: nosniff
< etag: W/"1fd-+fao8fhs8ofnuo93no"
< via: 1.1 vegur
< cf-cache-status: HIT
< age: 160
< accept-ranges: bytes
< nel: {"success_fraction":0,"report_to":"cf-nel","max_age":604800}
< server: cloudflare
< alt-svc: h3=":443"; ma=86400
< 
{
  "id": 1,
  "name": "Leanne Graham",
  "username": "Bret",
  "email": "Sincere@april.biz",
  "address": {
    "street": "Kulas Light",
    "suite": "Apt. 556",
    "city": "Gwenborough",
    "zipcode": "92998-3874",
    "geo": {
      "lat": "-37.3159",
      "lng": "81.1496"
    }
  },
  "phone": "1-770-736-8031 x56442",
  "website": "hildegard.org",
  "company": {
    "name": "Romaguera-Crona",
    "catchPhrase": "Multi-layered client-server neural-net",
    "bs": "harness real-time e-markets"
  }
* Connection #0 to host jsonplaceholder.typicode.com left intact
}

Note que as primeiras linhas começam com o caracter >, indicando que esta é uma linha da requisição; após uma linha em branco (> apenas), seguem uma sucessão de linhas começadas por <, indicando os cabeçalhos da resposta. Após uma linha em branco da resposta, indicada por um < vazio, começam os dados da resposta. Note a grande quantidade de cabeçalhos que é trocado em cada request/response ;)

Requisição POST para Enviar Dados para uma API: ReqRes.in

O ReqRes.in é outra API de teste que permite fazer requisições HTTP simuladas. Vamos usar o curl para fazer uma requisição POST e enviar dados JSON para a rota "/users" com o objetivo de criar um novo usuário.

curl -X POST -H "Content-Type: application/json" -d '{"name": "John Doe", "job": "Developer"}' https://reqres.in/api/users

Conclusão

Este artigo fornece uma introdução à arquitetura cliente-servidor e ao protocolo HTTP, que são conhecimentos importantes para aqueles que desejam trabalhar com o desenvolvimento de Aplicações para Web.

É importante ressaltar, entretanto, que não abordamos aqui algumas questões importantes relacionadas à segurança e métodos de autenticação, mas que serão abordados eventualmente em outros artigos.

PHP: mais alguns conceitos importantes da linguagem

Ranieri Valença — Tue, 25 Jul 2023 15:16:44 +0000

Tópicos

1. Introdução
2. Funções em PHP
       2.1. Funções
       2.2. Funções Anônimas
       2.3. Arrow Functions (Funções Flecha)
3. Manipulação de Arquivos em PHP
       3.1. Leitura de Arquivos
       3.2. Escrita em Arquivos
       3.3. Manipulador de Arquivo e Ponteiro de Arquivo
             a. Modos de Abertura de Arquivo
       3.4. Função fclose() e fechamento de arquivos
       3.5. Função file()
       3.6. Função unlink()
4. Manipulação de Arquivos CSV em PHP
       4.1. Função fgetcsv()
       4.2. Função str_getcsv
       4.3. Função fputcsv()
5. Manipulação de Strings em PHP
6. Includes e Requires
7. Manipulação de Datas em PHP

Introdução

Neste artigo vamos explorar mais alguns conceitos e funções importantes do PHP que são amplamente utilizados quando construímos Aplicações Web com esta linguagem.

Funções em PHP

Em PHP, as funções são blocos de código reutilizáveis que podem ser chamados em diferentes partes do código para executar uma tarefa específica. Elas ajudam a organizar e modularizar o código, tornando-o mais legível e fácil de manter.

Funções

Em PHP podemos criar funções comuns com nomes específicos. Essas funções podem receber parâmetros e retornar valores, permitindo uma maior modularização e organização do código.

Exemplo de criação e chamada de função comum:

// Função que retorna a soma de dois números
function somar($a, $b) {
    return $a + $b;
}

// Chamada da função e atribuição do resultado a uma variável
$resultado = somar(5, 3);

echo $resultado; // Saída: 8

Funções Anônimas

Uma função anônima é uma função que não possui um nome associado a ela. Elas são úteis quando você precisa de uma função temporária ou como argumento para outras funções, como em callbacks. Em PHP, as funções anônimas são criadas usando a palavra-chave function sem um nome seguido de parênteses e chaves para delimitar o bloco de código.

Exemplo de função anônima:

$add = function ($a, $b) {
    return $a + $b;
};

$result = $add(5, 3); // Chama a função anônima e atribui o resultado a $result
echo $result; // Saída: 8

Arrow Functions (Funções Flecha)

As arrow functions foram introduzidas no PHP 7.4 e são uma forma mais concisa de definir funções anônimas com apenas uma expressão. Elas permitem que você escreva funções de forma mais sucinta usando uma sintaxe reduzida.

Exemplo de arrow function:

$add = fn($a, $b) => $a + $b;

$result = $add(5, 3);
echo $result; // Saída: 8

Manipulação de Arquivos em PHP

PHP oferece diversas funções para a manipulação de arquivos, permitindo que você leia e escreva em arquivos, verifique informações de arquivos e diretórios, crie e exclua arquivos e diretórios, entre outras operações.

Leitura de Arquivos

Para ler o conteúdo de um arquivo em PHP, você pode utilizar a função file_get_contents() ou fopen() combinada com fread().

Exemplo de leitura de arquivo com file_get_contents():

$conteudo = file_get_contents('arquivo.txt');
echo $conteudo;

Esta função abre o arquivo, lê seu conteúdo, fecha o arquivo e retorna o seu conteúdo.

Exemplo de leitura de arquivo com fopen() e fread():

$handle = fopen('arquivo.txt', 'r');
$conteudo = fread($handle, filesize('arquivo.txt'));
fclose($handle);
echo $conteudo;

Escrita em Arquivos

Para escrever em um arquivo em PHP, você pode usar a função file_put_contents() ou fopen() combinada com fwrite().

Exemplo de escrita em arquivo com file_put_contents():

$conteudo = 'Este é um texto para escrever no arquivo.';
file_put_contents('arquivo.txt', $conteudo);

A função file_put_contents() apaga o conteúdo do arquivo e o substitui pelo conteúdo que está sendo passado como argumento.

Exemplo de escrita em arquivo com fopen() e fwrite():

$handle = fopen('arquivo.txt', 'w');
$conteudo = 'Este é um texto para escrever no arquivo.';
fwrite($handle, $conteudo);
fclose($handle);

Manipulador de Arquivo e Ponteiro de Arquivo

Quando nos exemplos anteriores utilizamos a função fopen() para abrir um arquivo em PHP, ela retorna um manipulador de arquivo, que é um recurso que representa o arquivo aberto. Esse manipulador de arquivo é usado posteriormente em outras funções de leitura e escrita para realizar operações no arquivo.

O ponteiro de arquivo é uma posição interna que indica a posição atual de leitura ou escrita no arquivo. Quando você abre um arquivo usando fopen(), o ponteiro de arquivo é posicionado no início do arquivo por padrão. À medida que você lê ou escreve no arquivo, o ponteiro de arquivo é movido para a próxima posição. Isso permite que você leia ou escreva dados em posições específicas do arquivo.

No exemplo anterior utilizamos a função filesize() para recuperar o tamanho em bytes do arquivo, de forma que lemos o arquivo completo de uma única vez. Mas também é possível utilizar a função fread() para ler parte do arquivo:

$handle = fopen('arquivo.txt', 'r');
$conteudo = fread($handle, 100); // Lê os primeiros 100 bytes do arquivo
fclose($handle);
echo $conteudo;

Modos de Abertura de Arquivo

Ao usar a função fopen() para abrir um arquivo em PHP, você deve especificar um modo de abertura para indicar como o arquivo será manipulado. Existem diferentes modos de abertura, que determinam se o arquivo será aberto apenas para leitura, apenas para escrita, para leitura e escrita, e se o ponteiro de arquivo será posicionado no início, no final ou em outras posições do arquivo.

Alguns dos modos de abertura mais comuns são:

'r': Abre o arquivo somente para leitura. O ponteiro de arquivo é posicionado no início do arquivo (modo padrão).
'w': Abre o arquivo somente para escrita. Se o arquivo já existir, seu conteúdo será apagado. Se o arquivo não existir, ele será criado.
'a': Abre o arquivo para escrita, mas posiciona o ponteiro de arquivo no final do arquivo. Se o arquivo não existir, ele será criado.
'r+': Abre o arquivo para leitura e escrita. O ponteiro de arquivo é posicionado no início do arquivo.

Exemplo de uso de fopen() com diferentes modos:

$handleRead = fopen('arquivo.txt', 'r');
$handleWrite = fopen('arquivo.txt', 'w');
$handleAppend = fopen('arquivo.txt', 'a');
$handleReadWrite = fopen('arquivo.txt', 'r+');

Nota importante: conforme mencionado anteriormente, abrir um arquivo em modo w irá apagar seu conteúdo caso o arquivo já exista. Portanto, tenha cuidado ao usar esse modo de abertura, já que ele pode implicar em perda de dados.

Função `fclose()` e fechamento de arquivos

Após abrir um manipulador de arquivo em PHP, é importante fechá-lo para que o sistema operacional tenha o recurso liberado. Naturalmente todos os manipuladores de arquivos (e outros tipos de manipuladores do tipo resource) são liberados após a execução de um script PHP, mas problemas podem acontecer caso você precise lidar novamente com arquivos que foram previamente abertos no mesmo arquivo, como por exemplo se você quiser renomeá-lo. Por isso é sempre uma boa prática fechar os manipuladores que forem abertos.

Função `file()`

A função file() é uma maneira conveniente de ler todo o conteúdo de um arquivo e armazená-lo em um array. Cada elemento do array representa uma linha do arquivo, incluindo os caracteres de quebra linha que existirem no final da linha:

$linhas = file('arquivo.txt');
foreach ($linhas as $linha) {
    echo $linha;
}

Função `unlink()`

A função unlink() é usada para excluir um arquivo em PHP. Cuidado ao utilizar esta função, pois a exclusão é irreversível e não é possível recuperar o arquivo após a remoção.

Exemplo de uso da função unlink():

if (file_exists('arquivo.txt')) {
    unlink('arquivo.txt');
    echo 'Arquivo excluído com sucesso.';
} else {
    echo 'O arquivo não existe.';
}

Outras funções e informações sobre manipulação de arquivos em PHP podem ser consultadas na seção correspondente do manual do PHP

Manipulação de Arquivos CSV em PHP

O formato CSV (Comma-Separated Values) é amplamente utilizado para armazenar dados tabulares, onde cada linha representa um registro e os valores são separados por vírgulas (ou outros delimitadores). Em PHP, existem funções específicas para lidar com arquivos CSV.

Função `fgetcsv()`

A função fgetcsv() é usada para ler uma linha de um arquivo CSV e retorná-la como um array. Ela identifica automaticamente os campos separados por vírgulas e os coloca em elementos do array. Essa leitura funciona como a função fread(), movendo o ponteiro interno do arquivo para a próxima linha. Quando a função fgetcsv() é chamada no final do arquivo, ela retorna o valor booleano false.

$handle = fopen('dados.csv', 'r');
while (($linha = fgetcsv($handle)) !== false) {
    print_r($linha);
}
fclose($handle);

Função str_getcsv

A função str_getcsv() é semelhante à fgetcsv(), mas ela opera em uma string em vez de um arquivo. Ela analisa uma string CSV e retorna um array com os valores:

$dados = 'João,25,"São Paulo"';
$linha = str_getcsv($dados);
print_r($linha); // Saída: Array ( [0] => João [1] => 25 [2] => São Paulo )

Função `fputcsv()`

A função fputcsv é usada para escrever uma linha em um arquivo CSV. Ela recebe um array como entrada e escreve os valores separados por vírgulas no arquivo:

$dados = array("João", 25, "São Paulo");
$handle = fopen('dados.csv', 'a');
fputcsv($handle, $dados);
fclose($handle);

Manipulação de Strings em PHP

PHP possui uma variedade de funções para a manipulação de strings, permitindo que você realize tarefas como concatenação, busca, substituição, formatação, entre outras.

Exemplo de manipulação de strings:

$texto = 'Olá, mundo!';
echo strlen($texto); // Saída: 12 (tamanho da string)
echo strtoupper($texto); // Saída: OLÁ, MUNDO! (conversão para maiúsculas)
echo str_replace('mundo', 'amigo', $texto); // Saída: Olá, amigo! (substituição de texto)

Outras funções para manipulação de strings podem ser vistas diretamente no manual do php

Includes e Requires

Em PHP, os includes e requires são utilizados para incluir o conteúdo de outros arquivos PHP no arquivo atual. Isso é útil quando você deseja reutilizar código de outros arquivos ou dividir o código em partes menores para facilitar a manutenção.

A diferença entre include e require é a forma como eles tratam erros. Se um arquivo não for encontrado no include, o PHP emitirá um aviso (warning) e continuará a execução do script. Já o require emitirá um erro fatal (fatal error) e interromperá a execução do script caso o arquivo não seja encontrado.

Exemplo de uso de include:

// arquivo1.php
$mensagem = 'Olá, mundo!';

// arquivo2.php
include 'arquivo1.php';
echo $mensagem; // Saída: Olá, mundo!

Exemplo de uso de require:

// arquivo1.php
$mensagem = 'Olá, mundo!';

// arquivo2.php
require 'arquivo1.php';
echo $mensagem; // Saída: Olá, mundo!

Manipulação de Datas em PHP

PHP possui diversas funções para a manipulação de datas e horários, permitindo que você trabalhe com datas, faça cálculos, formate datas em diferentes formatos, entre outras operações.

Exemplo de manipulação de datas:

$dataAtual = date('Y-m-d'); // Obtém a data atual no formato YYYY-MM-DD
echo $dataAtual;

$dataFormatada = date('d/m/Y', strtotime('2023-07-24')); // Converte uma data para o formato DD/MM/YYYY
echo $dataFormatada;

Mais informações sobre funções relacionadas a datas em PHP podem ser encontradas no manual da linguagem.

Esses são apenas alguns dos tópicos fundamentais em PHP. Com esses recursos, você pode criar aplicações web dinâmicas, realizar operações com arquivos, manipular strings e trabalhar com datas de forma eficiente e flexível. O PHP é uma linguagem versátil e poderosa que pode ser aplicada em uma ampla variedade de cenários de desenvolvimento web. Com a prática e o aprendizado contínuo, você poderá aprimorar suas habilidades em PHP e desenvolver aplicações cada vez mais complexas e avançadas.

Linguagem PHP: Introdução ao Desenvolvimento Web

Ranieri Valença — Tue, 25 Jul 2023 14:20:22 +0000

Tópicos

1. Introdução
2. Interpretador de PHP
       2.1. Tags de Marcação de Início e Fim
             a. Códigos Fora das Tags:
       2.2. Comentários
       2.3. Tipos de Dados
       2.4. Operadores
       2.5. Variáveis
       2.6. Estruturas de Controle:
       2.7. Arrays e Arrays Associativos
       2.8. Loop foreach
       2.9. Loops com dois pontos e end
       2.10. Sintaxe Resumida do Echo
       2.11. Fim de Bloco de Código e Último Bloco de Código de um Arquivo
       2.12. Intercambiando Códigos PHP com HTML
             a. Exemplo com laço FOREACH
             b. Exemplo de instrução condicional IF/ELSE
3. Conclusão

Introdução

PHP é uma linguagem de programação amplamente utilizada para desenvolvimento web. Criada por Rasmus Lerdorf em 1994, PHP (que inicialmente significava "Personal Home Page", mas agora é uma sigla recursiva para "PHP: Hypertext Preprocessor") evoluiu para se tornar uma ferramenta poderosa e flexível para criar aplicações web dinâmicas.

Interpretador de PHP

PHP é uma linguagem interpretada, o que significa que o código-fonte PHP é lido e executado linha por linha durante o tempo de execução, em vez de ser compilado em um programa independente. O interpretador de PHP é um software que interpreta e executa os scripts PHP. Quando você executa um script PHP diretamente da linha de comando, os resultados são mostrados diretamente no terminal.

Tags de Marcação de Início e Fim

Em PHP, o código a ser interpretado é delimitado por tags de marcação especiais que indicam ao interpretador onde o código PHP começa e termina. As tags de marcação padrão são:

<?php
// Código PHP aqui
?>

Também é comum usar a tag curta <?, mas é importante notar que nem todos os servidores web suportam essa forma curta de tag e pode estar desabilitada nas configurações de PHP. No entanto, ao executar o script diretamente da linha de comando, as tags curtas geralmente são suportadas.

Códigos Fora das Tags:

Quando você executa um script PHP diretamente da linha de comando, qualquer conteúdo fora das tags de marcação <?php ?> é tratado como saída padrão e é exibido diretamente no terminal. Isso significa que você pode usar o PHP para gerar e mostrar informações no terminal, mesmo que não esteja rodando o script em um servidor web. Isso também significa que você pode escrever qualquer coisa fora das tags de marcação PHP para serem escritas diretamente na saída.

Por exemplo, considere que o código a seguir chama-se script.php:

Olá, sua idade é: <?php
$idade = 18;
echo $idade;
?>

Uma chamada no terminal por

php script.php

Teria como resultado

Olá, sua idade é 18

Se o seu código não contiver nenhuma tag PHP, o resultado da execução do script usando o interpretador do PHP será exatamente o conteúdo do arquivo.

Comentários

Em PHP, você pode adicionar comentários para documentar seu código. Comentários são trechos de texto que não são executados pelo interpretador e servem apenas para explicar o que o código faz. Existem dois tipos de comentários em PHP:

Comentários de uma única linha:

// Este é um comentário de uma única linha

Comentários de múltiplas linhas:

/* 
   Este é um comentário 
   de múltiplas linhas
*/

Tipos de Dados

PHP suporta vários tipos de dados:

int: Números inteiros, por exemplo, 10, -5, 1000.
float: Números com casas decimais, por exemplo, 3.14, -0.5.
string: Sequência de caracteres, por exemplo, "Olá mundo!", 'PHP é divertido!'.
boolean: Representa verdadeiro (true) ou falso (false).
null: Representa a ausência de valor.
array: Coleção de elementos, indexada numericamente.
object: Instâncias de classes definidas pelo usuário.
resource: Referência a recursos externos, como conexões de banco de dados ou manipuladores de arquivos.
callable: Representa um objeto ou função que pode ser chamado.

Operadores

PHP suporta diversos tipos de operadores:

Aritméticos: + (adição), - (subtração), * (multiplicação), / (divisão), % (módulo).
De Comparação: == (igual), != (diferente), > (maior que), < (menor que), >= (maior ou igual), <= (menor ou igual).
Lógicos: && (E lógico), || (OU lógico), ! (NÃO lógico).
De Atribuição: = (atribuição simples), += (adição com atribuição), -= (subtração com atribuição), *= (multiplicação com atribuição), /= (divisão com atribuição), entre outros.
De Incremento e Decremento: ++ (incremento), -- (decremento).
Ternário: condição ? valor_se_verdadeiro : valor_se_falso.
Concatenador: . (para concatenar strings).
Igualdade e Diferença Estritas: === (igualdade estrita) e !== (diferença estrita).

Os operadores de igualdade estrita (===) e diferença estrita (!==) são usados para comparar tanto o valor quanto o tipo de dados de duas expressões. Isso significa que, ao usar ===, as expressões devem ser idênticas em valor e tipo para que a comparação seja considerada verdadeira. Por outro lado, com !==, a comparação é verdadeira se as expressões tiverem valores ou tipos diferentes. Esses operadores são importantes quando é necessário garantir que tanto o valor quanto o tipo sejam levados em consideração durante as comparações.

Variáveis

As variáveis em PHP são precedidas pelo símbolo de dólar $ e podem ser definidas dinamicamente sem a necessidade de declarar um tipo. Veja um exemplo:

$nome = "João";
$idade = 25;

Estruturas de Controle:

As estruturas de controle em PHP são muito similares a outras linguagens de programação do tipo C-like, como JavaScript. Elas permitem que você controle o fluxo do programa. As principais estruturas de controle são:

IF, ELSEIF e ELSE:

$idade = 18;

if ($idade >= 18) {
    echo "Você é maior de idade.";
} elseif ($idade >= 16) {
    echo "Você é adolescente.";
} else {
    echo "Você é menor de idade.";
}

FOR:

for ($i = 1; $i <= 5; $i++) {
    echo "Número: " . $i . "\n";
}

WHILE:

$i = 1;
while ($i <= 5) {
    echo "Número: " . $i . "\n";
    $i++;
}

DO-WHILE:

$i = 1;
do {
    echo "Número: " . $i . "\n";
    $i++;
} while ($i <= 5);

Arrays e Arrays Associativos

Arrays são coleções de elementos que podem ser indexados numericamente iniciando no 0, assim como em C ou JavaScript. Em PHP, os arrays podem ser criados usando a função array() ou a notação de colchetes [] a partir da versão 5.4.

Dado o fato de que PHP é uma linguagem com tipagem dinâmica, os arrays podem ser mistos, ou seja, contendo elementos de diversos tipos de dados.

Veja um exemplo de array:

$frutas = array("maçã", "banana", "laranja");
// [0] => "maçã" / [1] => "banana" / [2] => "laranja"

Além disso, os arrays em PHP podem ter chaves não numéricas. Esses arrays são chamados de arrays associativos, e são arrays onde cada elemento tem uma chave do tipo string associada. Veja um exemplo:

$aluno = array("nome" => "Maria", "idade" => 20, "nota" => 9.5);

Loop foreach

O loop foreach é especialmente útil para iterar sobre os elementos de um array. Ele percorre cada elemento do array e executa um bloco de código para cada elemento. Veja um exemplo:

$frutas = array("maçã", "banana", "laranja");
foreach ($frutas as $fruta) {
    echo $fruta . "\n";
}

Isso produzirá a seguinte saída no terminal:

maçã
banana
laranja

No caso de arrays associativos, você pode acessar tanto a chave quanto o valor usando a seguinte sintaxe:

$aluno = array("nome" => "Maria", "idade" => 20, "nota" => 9.5);
foreach ($aluno as $chave => $valor) {
    echo $chave . ": " . $valor . "\n";
}

Isso produzirá a seguinte saída no terminal:

nome: Maria
idade: 20
nota: 9.5

Loops com dois pontos e end

Outra forma de escrever loops em PHP é delimitando o bloco de código do loop usando dois pontos (:) e end[nome do loop]. Essa forma torna o código mais legível quando se trabalha com blocos grandes de HTML que estão dentro do bloco do laço. Veja os exemplos:

$frutas = array("maçã", "banana", "laranja");
for ($i = 0; $i < sizeof($frutas); $i++):
    echo $frutas[$i] . "\n";
endfor;

No caso de arrays associativos:

$aluno = array("nome" => "Maria", "idade" => 20, "nota" => 9.5);
foreach ($aluno as $chave => $valor):
    echo $chave . ": " . $valor . "\n";
endforeach;

Sintaxe Resumida do Echo

Para imprimir valores na saída, você também pode usar a sintaxe resumida do echo, utilizando <?= $valor ?>:

$nome = "Maria";
echo "Olá, " . $nome . "!"; // Saída: Olá, Maria!

Pode ser escrito de forma mais concisa usando a sintaxe resumida:

<?php
$nome = "Maria";
?>
Olá, <?= $nome ?>! <!-- Saída: Olá, Maria! -->

Fim de Bloco de Código e Último Bloco de Código de um Arquivo

Em PHP, a última linha de um bloco de código não precisa de ponto e vírgula (;). Isso torna mais fácil adicionar ou remover linhas de código sem se preocupar com o ponto e vírgula na última linha.

Além disso, quando o arquivo PHP termina com um bloco de código, o último bloco de PHP não precisa ser fechado com ?>. Essa prática é comum em arquivos que contêm apenas código PHP e não incluem HTML ou outras marcações. Deixar o último bloco sem o fechamento ?> ajuda a evitar espaços em branco ou caracteres adicionais após o fechamento do PHP, o que poderia causar erros em determinadas situações.

Intercambiando Códigos PHP com HTML

Uma das principais vantagens do PHP é a capacidade de intercambiar códigos PHP com HTML, permitindo a criação de páginas web dinâmicas, onde o conteúdo pode variar de acordo com as condições definidas no código PHP. Isso é especialmente útil quando se trabalha com estruturas de controle, como laços e instruções condicionais, que podem ser facilmente integradas ao HTML usando a sintaxe de dois pontos e end.

Vamos ver como podemos utilizar a sintaxe de dois pontos e end para intercalar estruturas de controle PHP com blocos de HTML.

Exemplo com laço FOREACH

Suponha que temos um array contendo alguns nomes de frutas e queremos exibi-los em uma lista não ordenada (<ul>) em nosso HTML:

<?php
$frutas = array("maçã", "banana", "laranja");
?>
<ul>
<?php foreach ($frutas as $fruta): ?>
    <li><?= $fruta ?></li>
<?php endforeach ?>
</ul>

O laço foreach percorre o array $frutas e para cada elemento, o código HTML é gerado dentro do laço, exibindo cada fruta em um elemento <li> da lista não ordenada. Note também que aqui estamos usando o endforeach sem ponto-e-vírgula no final, já que ele é o último (e único) comando do bloco em questão. O mesmo acontece o bloco que escreve a variável $fruta

Exemplo de instrução condicional IF/ELSE

Suponha que temos uma variável $idade e queremos exibir uma mensagem personalizada com base na idade em nosso HTML:

<?php
$idade = 25;
?>
<?php if ($idade >= 18): ?>
    <p>Você é maior de idade.</p>
<?php else: ?>
    <p>Você é menor de idade.</p>
<?php endif ?>

Neste exemplo, usamos a instrução condicional if/else para verificar se a idade é maior ou igual a 18. Dependendo do resultado, exibimos uma mensagem apropriada no HTML usando <p> (parágrafo).

Essa abordagem facilita a criação de páginas web dinâmicas, pois podemos incorporar lógica de programação PHP diretamente em nossos arquivos HTML. Dessa forma, podemos construir interfaces interativas que se adaptam a diferentes cenários e situações, proporcionando uma experiência mais personalizada e agradável aos usuários.

Conclusão

Com isso, você já é capaz de construir scripts simples utilizando PHP e HTML (ou apenas texto puro, se assim desejar) e executá-los no terminal para ver os resultados.

A seguir, vamos falar sobre mais alguns recursos importantes da linguagem PHP e abordar questões relacionadas ao modelo cliente-servidor e o protocolo HTTP que são os fundamentos da Internet.

Fundamentos do Desenvolvimento Web: uma rápida revisão

Ranieri Valença — Mon, 24 Jul 2023 18:43:47 +0000

Tópicos

1. Introdução
2. Sistema Operacional
       2.1. Terminal de comando
3. Sistema de Arquivos e Diretórios
       3.1. Programas e Linguagem de Programação
             a. Linguagens Compiladas
             b. Linguagens Interpretadas
4. Comandos básicos do terminal
5. PATH
6. Editor de Texto e IDE
       6.1. O VSCode
7. Utilizando o Windows Subsystem for Linux (WSL) no Windows
       7.1. Habilitando o WSL
       7.2. Iniciando e Utilizando o WSL
       7.3. Intercâmbio com o Windows
       7.4. Desenvolvimento Web com WSL
8. Codificação de Caracteres e UTF-8
       8.1. ASCII (American Standard Code for Information Interchange)
       8.2. Unicode
       8.3. UTF-8 (Unicode Transformation Format - 8 bits)
       8.4. Quebras de Linha, Retorno de Carro e Escape de Caracteres em Strings

Introdução

Antes de começarmos a entender os conceitos básicos de desenvolvimento web, é importante revisar alguns conhecimentos fundamentais de computação e programação. Por isto este artigo trata de alguns conceitos importantes desde sistemas operacionais até a utilização de IDEs e terminais de comando.

Sistema Operacional

Um sistema operacional é um software fundamental que atua como uma interface entre o hardware do computador e os programas que são executados nele. Ele gerencia os recursos do sistema, como processador, memória, dispositivos de entrada e saída, e permite que os usuários interajam com o computador de forma eficiente. Naturalmente dentro do mundo do Desenvolvimento Web, lidamos com três tipos de sistemas operacionais diferentes: Windows, Linux e MacOS. Cada um destes sistemas possui características diferentes dos demais, mas funcionalmente ambos se comportam de maneira similar no tocante ao desenvolvimento, visto que a nível de kernel todos têm funções semelhantes (apesar de diferenças significativas no tocante a, por exemplo, instalação de aplicações).

Um aspecto importante a ser abordado sobre os sistemas operacionais é o terminal de comando, que abordaremos a seguir.

Terminal de comando

O terminal de comando, também conhecido como prompt de comando ou shell, é uma interface de linha de comando que permite aos usuários interagir diretamente com o sistema operacional por meio de comandos textuais. Enquanto a maioria dos usuários interage com o sistema operacional através de uma interface gráfica, o terminal oferece uma maneira poderosa e eficiente de executar tarefas e comandos complexos.

No contexto de desenvolvimento de Aplicações Web, é bastante comum utilizar o terminal de comando para automatizar tarefas, manipular diretórios e arquivos, instalar ou remover programas e dependências e para fazer configurações. Apesar de algumas destas tarefas poderem ser executadas de forma até mesmo mais eficiente através da interface gráfica (como por exemplo a manipulação de arquivos), a utilização do terminal de comando é geralmente recomendada quando trabalhamos com desenvolvimento de aplicações.

Mais a frente falaremos de alguns comandos básicos do terminal de comando.

Sistema de Arquivos e Diretórios

O sistema de arquivos é a base para o armazenamento e organização de dados em um computador. Os dados são armazenados em arquivos, que por sua vez ficam armazenados em pastas (ou diretórios). Cada uma destas pastas pode estar dentro de outras pastas, formando uma estrutura hierárquica.

Cada arquivo ou diretório possui um nome, que serve como seu identificador. Em sistemas Linux, os nomes são case sensitives ("sensíveis ao caso"), o que significa que letras maiúsculas e minúsculas são tratadas de forma diferente. Assim, arquivo.txt é diferente de Arquivo.txt, mesmo que ambos estejam dentro do mesmo diretório. Esta mesma observação vale para diretórios, portanto é importante estar atento às letras maiúsculas e minúsculas enquanto estiver lidando com arquivos.

Outro ponto importante a ser lembrado é que essa estrutura hierárquica tem um fim, o que chamamos de diretório raiz. O diretório raiz em sistemas de arquivos baseados em Unix (Linux e MacOS, por exemplo), é o /; este é o ponto de montagem do sistema de arquivos. No caso de sistemas Windows, a raiz é geralmente indicada por uma letra (C: ou D:, por exemplo).

Assim, dentro dessa estrutura hierárquica e sabendo da identificação através de nomes, o caminho de um arquivo é a estrutura de diretórios em que ele está contido desde a raiz. Por exemplo, C:\users\ranieri\Desktop\teste.txt ou /home/ranieri/desktop/teste.txt. Isto é o que chamamos de caminho absoluto, pois é o caminho completo do arquivo desde a raiz. Podemos também ter caminhos relativos. Neste caso, . refere-se ao diretório em questão onde o arquivo está e .. refere-se ao diretório raiz.

Por exemplo, considere que estamos "olhando" o arquivo /home/ranieri/desktop/teste.txt. A partir deste arquivo, se quisermos referenciar um arquivo nomes.txt que está no mesmo diretório (/home/ranieri/desktop/nomes.txt), poderíamos referenciá-lo usando ./nomes.txt, já que ele está no mesmo diretório. Se, por outro lado, quiséssemos referenciar o arquivo localizado em /home/ranieri/.ssh/id_rsa teríamos que usar o identificador ../.ssh/id_rsa, ou seja, voltando ao diretório pai (../ refere-se à /home/ranieri, diretório pai de desktop que é onde o arquivo teste.txt está localizado).

Programas e Linguagem de Programação

Em termos simples, um programa é um conjunto de instruções escritas por um programador para que um computador execute tarefas específicas. Essas tarefas podem ser desde cálculos matemáticos até a execução de ações complexas em aplicativos, jogos ou servidores web. Os programas são a base de tudo o que fazemos em nossos computadores e dispositivos eletrônicos.

Já as linguagens de programação são conjuntos de regras e instruções utilizadas para desenvolver programas e aplicativos de computador. Elas servem como uma ponte de comunicação entre os seres humanos e as máquinas, permitindo que os programadores expressem suas ideias e lógica de programação de maneira estruturada e compreensível para os computadores.

Linguagens Compiladas

Linguagens de programação compiladas são aquelas em que o código-fonte é traduzido para código de máquina antes da execução do programa. O processo de compilação é realizado por um software chamado compilador, que analisa todo o código-fonte e o converte em um arquivo executável específico para o sistema operacional em que o programa será executado. Esse arquivo executável é independente do código-fonte original e pode ser distribuído para ser executado em diferentes sistemas, desde que exista uma versão compatível do compilador para cada plataforma.

Exemplos de linguagens compiladas incluem C, C++, Rust e Go. Quando um programa é escrito nessas linguagens, o código-fonte é traduzido em linguagem de máquina (também chamado de binário) pelo compilador antes da execução.

Linguagens Interpretadas

Linguagens de programação interpretadas são aquelas em que o código-fonte é traduzido para código de máquina linha por linha em tempo real, enquanto o programa é executado. Em vez de gerar um arquivo executável independente, o código-fonte é lido e interpretado por um programa chamado interpretador. O interpretador executa cada instrução do código em sequência, realizando as ações necessárias conforme encontradas no programa.

Exemplos de linguagens interpretadas incluem Python, JavaScript, Ruby e PHP. Ao executar um programa escrito nessas linguagens, é necessário ter o interpretador instalado no sistema operacional, pois ele será responsável por interpretar e executar o código. Por exemplo, quando executamos um código escrito em JavaScript, é comum fazermos uma chamada no terminal de comando similar a:

node my_code.js

Isso significa que o programa node será executado e irá interpretar o código escrito no arquivo my_code.js

Comandos básicos do terminal

Aqui vamos tratar alguns comandos extremamente básicos para utilizar o terminal de comando usando tanto Windows quando Linux (estes comandos no MacOS serão iguais aos do Linux)

Listar Arquivos e Diretórios:
Windows:

dir

Linux:

ls

Mudar de Diretório:
Windows:

cd [nome do diretório]

Linux:

cd [nome do diretório]

Criar Diretório:
Windows:

mkdir [nome do diretório]

Linux:

mkdir [nome do diretório]

Limpar a Tela do Terminal:
Windows:

cls

Linux:

clear

Copiar Arquivos:
Windows:

copy [origem] [destino]

Linux:

cp [origem] [destino]

Mover Arquivos:
Windows:

move [origem] [destino]

Linux:

mv [origem] [destino]

Remover Arquivos:
Windows:

del [nome do arquivo]

Linux:

rm [nome do arquivo]

Executar um Programa:
Windows:

[programa].exe

Linux:

./[programa]

É importante notar que, além das diferenças nos comandos, os sistemas operacionais têm algumas particularidades em relação à estrutura de diretórios e aos nomes de arquivos. No Windows, utiliza-se o caractere de barra invertida \ para separar diretórios, enquanto no Linux usa-se a barra /. Além disso, como já falamos anteriormente, no Windows, os nomes de arquivos e diretórios não diferenciam maiúsculas de minúsculas, enquanto no Linux, são considerados como diferentes.

PATH

O conceito de PATH é fundamental para entender como os comandos são executados. O PATH é uma variável de ambiente (um valor nomeado que pode ser acessado e utilizado por programas em um sistema operacional para armazenar informações relevantes) que contém uma lista de diretórios em que o sistema operacional procura por executáveis quando um comando é digitado no terminal.

Quando um comando é inserido no terminal, o sistema verifica o diretório atual (o diretório em que o usuário está no momento) e, em seguida, busca o comando nos diretórios listados na variável PATH. Se o executável do comando for encontrado em um desses diretórios, o sistema executará o comando. Caso contrário, o sistema exibirá uma mensagem de erro indicando que o comando não foi encontrado.

A configuração adequada do PATH é essencial para garantir que os comandos sejam executados corretamente, principalmente quando se trabalha com desenvolvimento de aplicações web, pois muitas vezes é necessário utilizar ferramentas e programas que são instalados em diretórios específicos.

Por exemplo, ao instalar ferramentas como o Node.js, o PHP ou o Python em um sistema operacional, essas ferramentas geralmente são adicionadas aos diretórios do PATH para que possam ser acessadas de qualquer local no terminal de comando. Isso permite que os desenvolvedores executem essas ferramentas diretamente do terminal, sem a necessidade de fornecer o caminho completo para o executável.

A configuração do PATH varia de acordo com o sistema operacional utilizado. No Windows, por exemplo, é possível configurá-lo através das variáveis de ambiente do sistema, dentro do Painel de Controle. Já no Linux e MacOS, o PATH pode ser configurado no arquivo de perfil do usuário, como o .bashrc ou o .bash_profile.

No desenvolvimento de aplicações web, ter um PATH configurado adequadamente é crucial para garantir a facilidade de uso e a eficiência das ferramentas e comandos utilizados no terminal de comando. Com o PATH configurado corretamente, os desenvolvedores podem agilizar suas tarefas e aproveitar ao máximo as capacidades oferecidas pelo terminal de comando em seus projetos.

Editor de Texto e IDE

Um editor de texto é uma ferramenta essencial para escrever código, e uma IDE (Ambiente de Desenvolvimento Integrado) oferece recursos adicionais para facilitar o desenvolvimento.

O VSCode

O Visual Studio Code (VSCode) é um dos editores de texto mais populares no desenvolvimento web moderno. Uma das suas principais vantagens é sua vasta biblioteca de extensões que oferecem recursos adicionais e suporte para várias linguagens de programação e frameworks. Com estas extensões e plugins é possível torná-lo uma IDE, com todas as funcionalidades necessárias para o desenvolvimento.

Além disso, é possível personalizar as configurações do VSCode de forma a otimizar seu fluxo de trabalho, alterando atalhos para funções usadas comumente ou alterando as cores do tema para melhorar sua acessibilidade.

Utilizando o Windows Subsystem for Linux (WSL) no Windows

O Windows Subsystem for Linux (WSL) é uma ferramenta poderosa que permite aos usuários do Windows executar uma distribuição Linux completa diretamente no sistema operacional Windows. Isso possibilita a utilização de comandos e ferramentas nativas do Linux no ambiente do Windows, incluindo no desenvolvimento web.

Habilitando o WSL

Para utilizar o WSL, é necessário habilitá-lo no Windows. Nas versões mais recentes do Windows, o WSL está disponível como uma funcionalidade integrada. Para habilitá-lo, siga estes passos:

Abra o "Painel de Controle" do Windows.
Clique em "Programas" ou "Programas e Recursos".
No painel esquerdo, clique em "Ativar ou desativar recursos do Windows".
Localize "Windows Subsystem for Linux" na lista e marque a caixa de seleção ao lado.
Clique em "OK" e aguarde o Windows fazer as alterações necessárias.

Após habilitar o WSL, você precisará instalar uma distribuição Linux através da Microsoft Store. Atualmente, existem várias opções disponíveis, incluindo o Ubuntu, Debian, Fedora e outras.

Iniciando e Utilizando o WSL

Após instalar a distribuição Linux de sua escolha, você pode iniciá-la como qualquer outro aplicativo do Windows. Basta procurar a distribuição no menu Iniciar e clicar em "Iniciar" para abrir um terminal Linux diretamente no Windows.

No ambiente do WSL, você pode utilizar os mesmos comandos e ferramentas que usaria em um sistema Linux tradicional. Isso inclui comandos como ls, cd, mkdir, rm, entre outros. Além disso, você pode instalar pacotes e bibliotecas usando o gerenciador de pacotes da distribuição Linux que você escolheu.

Intercâmbio com o Windows

Um dos recursos interessantes do WSL é a capacidade de intercambiar arquivos e diretórios entre o ambiente do Windows e o ambiente Linux. Dentro do terminal do WSL, você pode acessar os arquivos do Windows através do caminho /mnt/c/ (ou /mnt/d/ para outra partição, se aplicável).

Por exemplo, para acessar a pasta "Documentos" do Windows no ambiente do WSL, você pode utilizar o seguinte comando:

cd /mnt/c/Users/SeuUsuario/Documents

Dessa forma, você pode trabalhar com os arquivos em ambos os ambientes de forma integrada.

Desenvolvimento Web com WSL

O WSL é especialmente útil no desenvolvimento web, pois permite que você utilize todas as ferramentas e comandos familiares do ambiente Linux sem precisar sair do sistema operacional Windows. Você pode executar servidores web, compilar código, gerenciar pacotes e dependências, e realizar outras tarefas típicas do desenvolvimento web diretamente no terminal do WSL.

Além disso, a integração com o Visual Studio Code (VSCode) é bastante fluída, permitindo que você utilize o editor de texto para desenvolvimento web com suporte total ao ambiente do WSL.

Codificação de Caracteres e UTF-8

No desenvolvimento web, a codificação de caracteres é um aspecto essencial para garantir que os dados sejam representados corretamente e possam ser interpretados corretamente pelos navegadores e servidores. Nesta seção, abordaremos alguns conceitos importantes sobre a codificação de caracteres, incluindo ASCII, Unicode e UTF-8.

ASCII (American Standard Code for Information Interchange)

O ASCII é um dos primeiros padrões de codificação de caracteres amplamente utilizado na computação. Ele foi desenvolvido nos anos 60 e utiliza um conjunto de 128 caracteres diferentes, incluindo letras maiúsculas e minúsculas, números, símbolos de pontuação e caracteres especiais, como tabulação e quebra de linha. Cada caractere é representado por um valor numérico de 7 bits, variando de 0 a 127.

Por exemplo, o valor ASCII para a letra 'A' é 65, e o valor ASCII para a letra 'a' é 97. Os números 0 a 9 têm os valores ASCII de 48 a 57, respectivamente.

Para visualizar a tabela completa de caracteres ASCII, você pode consultar a tabela ASCII na Wikipedia.

Apesar de ser amplamente utilizado em seus primórdios, o ASCII apresenta limitações ao suportar apenas um conjunto limitado de caracteres, o que torna inviável a representação de idiomas e símbolos de outros alfabetos.

Unicode

Para solucionar as limitações do ASCII, o Unicode foi desenvolvido para permitir a representação de um conjunto mais amplo de caracteres, incluindo símbolos, letras e caracteres de idiomas de todo o mundo. O Unicode atribui um número único (chamado de ponto de código) a cada caractere, e atualmente suporta mais de 143.000 pontos de código, permitindo a inclusão de diversos sistemas de escrita, emojis e caracteres especiais.

A tabela Unicode também inclui os caracteres ASCII originais, tornando-o compatível com sistemas legados.

UTF-8 (Unicode Transformation Format - 8 bits)

O UTF-8 é um dos esquemas de codificação mais populares e amplamente utilizados do Unicode. Ele utiliza um número variável de bytes (8 bits) para representar cada caractere, o que permite que os caracteres ASCII sejam representados usando um único byte, mantendo a compatibilidade com sistemas legados que utilizam o ASCII.

Caracteres não ASCII são representados por um número variável de bytes, dependendo do ponto de código do caractere no Unicode. Isso torna o UTF-8 uma codificação eficiente e econômica para armazenar e transmitir texto multilíngue, uma vez que caracteres menos comuns usam mais bytes, enquanto caracteres mais comuns usam menos.

Por exemplo:

Caracteres ASCII (0 a 127): Representados em UTF-8 usando 1 byte.
Caracteres latinos comuns (á, é, í, ó, ú, etc.): Representados em UTF-8 usando 2 bytes.
Caracteres de outros alfabetos e emojis: Representados em UTF-8 usando 3 ou 4 bytes.

O UTF-8 é amplamente recomendado como a codificação padrão para documentos e páginas da web, pois suporta todos os caracteres necessários para uma representação completa e precisa de texto multilíngue.

Quebras de Linha, Retorno de Carro e Escape de Caracteres em Strings

Em linguagens de programação, uma string é uma sequência de caracteres. Para representar caracteres especiais, como as quebras de linha e o retorno de carro, dentro de uma string, são utilizados os chamados caracteres de escape. O caractere de escape mais comum é a barra invertida (\). Quando seguida de um caractere especial, ela indica que o caractere seguinte deve ser tratado de forma especial.

Por exemplo:

\n: Representa uma quebra de linha.
\r: Representa um retorno de carro.
\t: Representa uma tabulação.
\": Representa uma aspa dupla.
\': Representa uma aspa simples.
\\: Representa uma barra invertida.

Esses caracteres de escape permitem que você inclua caracteres especiais dentro de uma string, sem que eles sejam interpretados de forma literal.

Em sistemas Windows, as quebras de linha são representadas pelo par de caracteres \r\n (retorno de carro seguido de quebra de linha), enquanto em sistemas baseados em Unix (Linux, MacOS), apenas o caractere \n é utilizado para representar uma quebra de linha.

Com essa breve revisão, podemos passar para os próximos tópicos desta série e começar a falar sobre linguagens de programação para Desenvolvimento Web, protocolo HTTP e outras coisas mais.