O que é HTTP - Internet

Dando continuidade à nossa série de introdução à internet, no post anterior Como funciona a internet? - Internet 1/5, introduzimos algumas siglas como HTTP e HTTPS. Desta vez, iremos nos aprofundar mais no conceito do HTTP e entender por que ele foi criado, além de explorar sua linha do tempo ao longo do desenvolvimento da web.

Falaremos sobre "What is HTTP? / O que é HTTP?".

Motivação e criação do HTTP

O HTTP (Hypertext Transfer Protocol) foi desenvolvido por Tim Berners-Lee, conhecido como o pai da internet, juntamente com sua equipe no CERN (Organização Europeia para a Pesquisa Nuclear), no início dos anos 1990. A criação do HTTP surgiu da necessidade de compartilhar informações e recursos de forma eficiente na World Wide Web, que já tinha 30 anos na época.

Berners-Lee estava trabalhando no desenvolvimento da Web, que envolvia a criação de um sistema para interligar documentos por meio de links. No entanto, foi necessário criar um protocolo que permitisse a transferência de dados de maneira padronizada e confiável entre os servidores web e os clientes, como navegadores.

Para isso, Berners-Lee e sua equipe se basearam em várias tecnologias e conceitos que já existiam na época:

Hipertexto: conceito que permite a criação de links entre diferentes documentos.
Modelo cliente-servidor: no qual um cliente solicita informações a um servidor que responde com os dados solicitados.
FTP (File Transfer Protocol): ideia de comandos e respostas para estabelecer uma comunicação entre o cliente e o servidor.

É importante destacar que o HTTP foi projetado para ser um protocolo simples e extensível, permitindo a adição de novos recursos e funcionalidades no futuro. Essa visão de futuro foi uma das razões pelas quais o HTTP se tornou amplamente adotado e evoluiu ao longo dos anos.

Vale ressaltar que houve várias atualizações menores e extensões ao longo dos anos para melhorar o protocolo e adicionar recursos adicionais. Apresentarei apenas algumas atualizações grandes e relevantes para o entendimento.

HTTP/0.9 - 1991

A primeira versão documentada do HTTP foi a HTTP/0.9, lançada em 1991. Foi o protocolo mais simples de todos os tempos, com apenas um método chamado GET para que um cliente pudesse solicitar uma página da web ao servidor.

Aqui está um exemplo de como uma requisição HTTP/0.9 poderia ser:

GET /index.html

Exemplo de resposta:

<html>
  ...
</html>

(connection closed)

HTTP/1.0 - 1996

Ao contrário de seu antecessor, o HTTP/1.0 era capaz de lidar com outros tipos de resposta, como imagens, arquivos de vídeo, texto simples ou qualquer outro tipo de conteúdo. Algumas das principais atualizações lançadas foram:

Adição de novos métodos, incluindo GET, POST e HEAD.
Adição de cabeçalhos HTTP tanto nas solicitações quanto nas respostas.
Adição de códigos de status para identificar a resposta.
Introdução de suporte a conjuntos de caracteres.
Adição de recursos como autorização e codificação de conteúdo.
Entre outros.

Aqui está um exemplo de como uma requisição HTTP/1.0 poderia ser:

GET /api/users/123 HTTP/1.0
Host: example.com
User-Agent: Mozilla/4.0 (compatible; MSIE 6.0; Windows NT 5.1)
Accept: application/json
Referer: <https://www.google.com/>
If-Modified-Since: Sat, 1 Jul 2023 12:00:00 GMT

Exemplo de resposta:

HTTP/1.0 200 OK
Date: Tue, 3 Jul 2023 15:30:00 GMT
Server: Apache/1.3.29 (Unix) PHP/4.4.2
Content-Type: text/html; charset=UTF-8
Content-Length: 1024
Expires: Tue, 3 Jul 2023 16:30:00 GMT
Last-Modified: Mon, 2 Jul 2023 14:30:00 GMT

(response body)
(connection closed)

No início da resposta, há o HTTP/1.0 (HTTP seguido pelo número da versão), seguido pelo código de status 200 e a descrição do código de status.

Nesta versão mais recente, os cabeçalhos de solicitação e resposta eram mantidos em formato ASCII, mas o corpo da resposta poderia ser de qualquer tipo, como imagem, vídeo, HTML, texto simples ou qualquer outro tipo de conteúdo.

Uma das principais desvantagens do HTTP/1.0 era que não era possível ter várias solicitações em uma única conexão. Isso significa que, sempre que um cliente precisava de algo do servidor, ele precisava abrir uma nova conexão TCP e, após o atendimento dessa única requisição, a conexão era encerrada.

HTTP/1.1 - 1999

Após três anos do HTTP 1.0, foi lançada a nova versão HTTP/1.1 em 1999. Ela trouxe diversas melhorias em comparação ao seu antecessor (HTTP/1.0). Algumas das principais melhorias incluídas foram:

Adição de novos métodos HTTP, incluindo PUT, PATCH, OPTIONS e DELETE.
Obrigação de identificação do nome do host no cabeçalho.
Conexões persistentes, ou seja, as conexões não eram fechadas por padrão e eram mantidas abertas, permitindo várias solicitações. Para fechar as conexões, era necessário enviar o cabeçalho "Connection: close" na requisição.
Pipelining, onde o cliente podia enviar múltiplas requisições ao servidor sem esperar a resposta do servidor. O servidor era responsável por retornar as respostas na ordem em que foram solicitadas. Para lidar com essas diversas requisições, era necessário enviar o cabeçalho "Content-Length".
Transferência em chunks, para conteúdo dinâmico em que não é possível identificar o "Content-Length". O servidor enviava o conteúdo em pedaços (chunks), adicionando o "Content-Length" para cada chunk. Após enviar todos os chunks, o servidor enviava um bloco vazio, com "Content-Length" igual a zero, indicando que a transferência foi concluída. Para isso, era necessário enviar o cabeçalho "Transfer-Encoding: chunked".
Cache.
Suporte a conjuntos de caracteres.
Negociação de idiomas.
Cookies de cliente.
Melhor suporte de compressão.
Entre outros.

Aqui está um exemplo de como uma requisição HTTP/1.1 poderia ser:

GET /api/users/123 HTTP/1.1
Host: example.com
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/91.0.4472.124 Safari/537.36
Accept: application/json
Accept-Language: en-US,en;q=0.9
Referer: <https://www.google.com/>
Authorization: Bearer eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJ1c2VySWQiOiIxMjM0NTY3ODkwIiwiaWF0IjoxNjI1NDU2NTY4LCJleHAiOjE2MjU0NTY3NjgsImlzcyI6ImV4YW1wbGUuY29tIiwic3ViIjoiYXV0aDB8NTg4ZjFmZGE0NzM0MDMwMDZkM2Y2Y2JhIiwiYXVkIjoiaHR0cHM6Ly9leGFtcGxlLmNvbSJ9.TMszXmUKITDFPf4AiwQ6MCdMbMw8uZlFWmBkOe4CEsA
If-None-Match: "abcdef123456"
If-Modified-Since: Sat, 1 Jul 2023 12:00:00 GMT
Cache-Control: no-cache
Cookie: sessionid=abcde12345; lang=en-US

Exemplo de resposta:

HTTP/1.1 200 OK
Date: Tue, 3 Jul 2023 15:30:00 GMT
Server: Apache/2.4.7 (Ubuntu)
Content-Type: application/json
Content-Length: 256
Cache-Control: public, max-age=3600
Expires: Tue, 3 Jul 2023 16:30:00 GMT
Last-Modified: Mon, 2 Jul 2023 14:30:00 GMT
ETag: "abcdef123456"
X-Powered-By: PHP/7.3.9
Set-Cookie: sessionid=abcde12345; path=/; HttpOnly; Secure
Strict-Transport-Security: max-age=31536000; includeSubDomains; preload
X-Frame-Options: DENY
X-Content-Type-Options: nosniff

(response body)
(connection closed)

SPDY - 2009

O Google começou a experimentar protocolos alternativos para tornar a web mais rápida e melhorar a segurança nas trocas de requisições. O principal objetivo era reduzir a latência das páginas. Com isso, em 2009, o projeto SPDY foi anunciado.

Foram realizados diversos testes para otimizar a velocidade e o desempenho, e percebeu-se que, ao focar na latência, haveria um ganho de desempenho constante. Isso levou ao desenvolvimento do SPDY.

Os principais recursos introduzidos pelo SPDY foram:

Compressão de cabeçalhos.
Multiplexação.
Priorização de requisições.
Push de recursos.
Stream ID e Stream Dependency.
Melhorias na segurança.
Entre outros.

Aqui está um exemplo de como uma solicitação e resposta no SPDY poderiam ser:

GET /pagina HTTP/1.1
Host: www.exemplo.com
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/58.0.3029.110 Safari/537.36
Accept: text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,*/*;q=0.8
Accept-Language: en-US,en;q=0.5
Referer: <https://www.exemplo.com/pagina-anterior>
Cookie: nome=valor; outro_nome=outro_valor
X-SPDY-Stream-ID: 1
X-SPDY-Priority: 3
X-SPDY-Session-ID: abcd1234
X-SPDY-Referrer: <https://www.exemplo.com/referencia>
X-SPDY-URL: /pagina
X-SPDY-Scheme: https
X-SPDY-Host: www.exemplo.com
X-SPDY-Protocol: http/1.1
X-SPDY-Version: 3.1
X-SPDY-Capabilities: spdy/3, http/1.1
X-SPDY-Headers: name,value
X-SPDY-SSL: true
X-SPDY-Status: active
X-SPDY-Compression: gzip
X-SPDY-Method: GET
X-SPDY-Content-Length: 0
X-SPDY-Content-Type: text/html
X-SPDY-Content-Encoding: deflate
X-SPDY-Upgrade: HTTP/1.1, HTTPS/1.3, IRC/6.9, RTA/x11, websocket
X-SPDY-Connection: keep-alive

Exemplo de resposta:

HTTP/1.1 200 OK
Date: Wed, 07 Jul 2023 15:30:00 GMT
Server: Apache/2.4.39 (Unix)
Content-Length: 245
Content-Type: text/html; charset=UTF-8
Expires: Wed, 07 Jul 2023 15:45:00 GMT
Cache-Control: max-age=900
X-SPDY-Stream-ID: 1
X-SPDY-Version: 3.1
X-SPDY-SSL: true
X-SPDY-Status: active
X-SPDY-Compression: gzip
X-SPDY-Content-Encoding: deflate
X-SPDY-Connection: keep-alive

(response body)
(connection closed)

HTTP/2 - 2015

Inspirado pelo SPDY, o HTTP/2 foi lançado em 2015 e trouxe recursos essenciais para a web como a conhecemos atualmente. Ele baseou-se na versão lançada pelo Google e aprimorou alguns recursos.

Os principais recursos introduzidos pelo HTTP/2 foram:

Uso de formato binário em vez de texto.
Multiplexação.
Compressão de cabeçalhos utilizando o HPACK.
Server Push.
Priorização de solicitações.
Melhorias na segurança.

Aqui está um exemplo de como uma solicitação e resposta no HTTP/2 poderiam ser:

GET /api/example?param1=value1&param2=value2 HTTP/2
Host: www.example.com
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/93.0.4577.82 Safari/537.36
Accept: text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,image/apng,*/*;q=0.8,application/signed-exchange;v=b3;q=0.9
Accept-Charset: utf-8
Accept-Encoding: gzip, deflate, br
Accept-Language: en-US,en;q=0.9
Referer: <https://www.example.com/home>
Cookie: session_id=1234567890; language=en_US
Authorization: Bearer eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJzdWIiOiIxMjM0NTY3ODkwIiwibmFtZSI6IkpvaG4gRG9lIiwiaWF0IjoxNTE2MjM5MDIyfQ.SflKxwRJSMeKKF2QT4fwpMeJf36POk6yJV_adQssw5c
Cache-Control: no-cache
Connection: keep-alive
Content-Type: application/json
DNT: 1
If-Match: "abcdef"
If-Modified-Since: Mon, 01 Jan 2023 00:00:00 GMT
If-None-Match: "xyz123"
If-Range: bytes=500-999
If-Unmodified-Since: Tue, 01 Jan 2023 00:00:00 GMT
Max-Forwards: 10
Pragma: no-cache
TE: trailers, deflate, gzip
Upgrade-Insecure-Requests: 1
X-Forwarded-For: 192.168.0.1
X-Forwarded-Host: www.example.com
X-Forwarded-Port: 443
X-Forwarded-Proto: https
X-Requested-With: XMLHttpRequest

Exemplo de resposta:

HTTP/2 200 OK
content-type: application/json
content-length: 124
cache-control: public, max-age=3600
date: Wed, 07 Jul 2023 12:00:00 GMT
server: ExampleServer/2.0

{
  "result": "success",
  "data": {
    "key1": "value1",
    "key2": "value2"
  },
  "message": "Request processed successfully"
}

HTTP/3 - 2021

A ultima versão lançada, e que usamos atualmente, é o HTTP/3, ele possuitodos os recursos das versões anteriores, porém utiliza QUIC invés de TCP para a parte da camada de transporte.

A maior motivação para que fosse trocado o TCP pelo QUIC, foi que por conta do HTTP/2 ser multiplexado, e o TCP ser executado em uma única conexão, todas as percas e retransmissão de pacotes que ocorrem na camada do TCP pode bloquear todos os outros fluxos.

Já o QUIC executa múltiplos fluxos e implementa as percas e retransmissão de pacotes independente para cara fluxo, ou seja, caso ocorra um erro, apenas o fluxo com dados naquele pacote irá ser bloqueado.

Em outubro de 2022, 26% de todos os sites estavam usando HTTP/3 .

Pudemos conhecer um pouco sobre as motivações que a CERN teve para dar inicio ao HTTP, sendo a base da web que conhecemos hoje.

Lembrando que o time da CERN reutilizou vários conceitos já existentes na época, trazendo uma nova perspectiva para nós como desenvolvedores, deixo a reflexão no ar.

Passei por cima de todas as atualizações mais impactantes para a evolução do HTTP que conhecemos hoje. Cada atualização é bem mais complexa do que eu apresentei, trouxe apenas alguns conceitos chaves.

No próximo artigo, irei introduzir o conceito de “DNS e como funciona”.

Fontes:

Everything you need to know about HTTP: https://cs.fyi/guide/http-in-depth

What is HTTP?: https://www.cloudflare.com/en-gb/learning/ddos/glossary/hypertext-transfer-protocol-http/

An overview of HTTP: https://developer.mozilla.org/en-US/docs/Web/HTTP/Overview

Protocolo HTTP: Estrutura, solicitações, respostas, métodos e códigos de status: https://www.diegomacedo.com.br/protocolo-http-estrutura-solicitacoes-respostas-metodos-e-codigos-de-status/#google_vignette