Transferência de Dados por URL no Linux

LinuxBeginner
Pratique Agora

Introdução

Bem-vindo ao laboratório de Transferência de Dados de URL no Linux. Neste laboratório, você aprenderá como transferir dados usando URLs em sistemas Linux. Esta é uma habilidade fundamental para administradores de sistemas, desenvolvedores e profissionais de segurança.

A principal ferramenta que aprenderemos é o curl, um utilitário de linha de comando poderoso para transferir dados com a sintaxe de URL. Você aprenderá como recuperar dados de websites, salvar conteúdo em arquivos, usar diferentes métodos HTTP e personalizar suas requisições com várias opções.

Ao final deste laboratório, você terá experiência prática com técnicas essenciais de transferência de dados que são comumente usadas em cenários do mundo real.

Este é um Lab Guiado, que fornece instruções passo a passo para ajudá-lo a aprender e praticar. Siga as instruções cuidadosamente para completar cada etapa e ganhar experiência prática. Dados históricos mostram que este é um laboratório de nível iniciante com uma taxa de conclusão de 95%. Recebeu uma taxa de avaliações positivas de 100% dos estudantes.

Entendendo os Fundamentos do Curl

curl é uma ferramenta de linha de comando para transferir dados com a sintaxe de URL. Ele suporta inúmeros protocolos, incluindo HTTP, HTTPS, FTP e muitos outros. Nesta etapa, você aprenderá o uso básico do curl para recuperar conteúdo da web.

Vamos começar abrindo um terminal. O terminal já deve estar no diretório /home/labex/project. Caso contrário, você pode mudar para este diretório usando:

cd ~/project

Seu Primeiro Comando curl

Vamos começar usando curl para recuperar conteúdo de um website. Digite o seguinte comando:

curl http://example.com

Após executar este comando, você deverá ver o conteúdo HTML de example.com exibido no seu terminal. Esta saída inclui tags HTML e todo o conteúdo da página web. A saída deve ser semelhante a esta:

<!doctype html>
<html>
<head>
    <title>Example Domain</title>
    ...
</head>
<body>
    <div>
        <h1>Example Domain</h1>
        <p>This domain is for use in illustrative examples in documents...</p>
        ...
    </div>
</body>
</html>

Isso demonstra o uso mais básico do curl - recuperar o conteúdo de uma URL e exibi-lo diretamente no terminal.

Entendendo a Saída

A saída que você vê é a resposta HTML bruta do servidor. Quando você visita um website usando um navegador, o navegador interpreta este HTML e o renderiza como uma página web formatada. No entanto, curl simplesmente mostra o conteúdo bruto.

Vamos tentar outro exemplo para ver conteúdo diferente. Execute:

curl https://httpbin.org/json

Desta vez, você deverá ver uma resposta JSON. A saída deve ser semelhante a:

{
  "slideshow": {
    "author": "Yours Truly",
    "date": "date of publication",
    "slides": [
      {
        "title": "Wake up to WonderWidgets!",
        "type": "all"
      },
      {
        "items": [
          "Why <em>WonderWidgets</em> are great",
          "Who <em>buys</em> WonderWidgets"
        ],
        "title": "Overview",
        "type": "all"
      }
    ],
    "title": "Sample Slide Show"
  }
}

Como você pode ver, curl pode recuperar diferentes tipos de conteúdo, dependendo do que o servidor fornece.

Salvando a Saída em Arquivos

Em muitos casos, você pode querer salvar o conteúdo que recupera em vez de apenas visualizá-lo no terminal. Nesta etapa, você aprenderá como salvar a saída do curl em arquivos.

Salvando Usando Redirecionamento de Saída

A maneira mais simples de salvar a saída de um comando curl é usando o redirecionamento com o operador >. Execute o seguinte comando:

curl http://example.com > example.html

Este comando recupera o conteúdo de example.com e o salva em um arquivo chamado example.html no seu diretório atual. Para verificar se o arquivo foi criado, execute:

ls -l example.html

Você deve ver o arquivo listado com seu tamanho e outros detalhes.

Para verificar o conteúdo do arquivo, você pode usar o comando cat:

cat example.html

Você deve ver o mesmo conteúdo HTML que foi exibido anteriormente no terminal.

Usando a Opção -o do curl

curl fornece uma opção específica -o (ou --output) para salvar o conteúdo recuperado em um arquivo. Isso é particularmente útil quando o redirecionamento de saída pode causar problemas. Vamos tentar:

curl -o httpbin_data.json https://httpbin.org/json

Este comando salva os dados JSON de httpbin.org em um arquivo chamado httpbin_data.json. Verifique a criação do arquivo com:

ls -l httpbin_data.json

E verifique seu conteúdo com:

cat httpbin_data.json

Criando um Diretório de Dados

É uma boa prática organizar seus arquivos. Vamos criar um diretório de dados dedicado (se ele ainda não existir) e salvar algum conteúdo lá:

mkdir -p data
curl -o data/google_data.txt http://www.google.com

O comando mkdir -p cria o diretório data se ele ainda não existir. A flag -p garante que nenhum erro seja relatado se o diretório já existir.

Agora, verifique se o arquivo foi criado no diretório de dados:

ls -l data/google_data.txt

Você deve ver o arquivo listado com seus detalhes.

Opções Avançadas do Curl

curl oferece muitas opções que permitem personalizar suas requisições. Nesta etapa, você aprenderá sobre algumas das opções mais úteis.

Modo Verboso

A opção -v (ou --verbose) diz ao curl para exibir informações detalhadas sobre a requisição e a resposta. Isso é particularmente útil para depuração. Execute:

curl -v http://example.com

Você deve ver muitas informações, incluindo:

  • Os cabeçalhos da requisição enviados pelo curl
  • Detalhes da conexão
  • Cabeçalhos da resposta do servidor
  • O conteúdo real da resposta

A saída será semelhante a esta (embora alguns detalhes variem):

*   Trying 93.184.216.34:80...
* Connected to example.com (93.184.216.34) port 80 (#0)
> GET / HTTP/1.1
> Host: example.com
> User-Agent: curl/7.81.0
> Accept: */*
>
* Mark bundle as not supporting multiuse
< HTTP/1.1 200 OK
< Age: 578793
< Cache-Control: max-age=604800
< Content-Type: text/html; charset=UTF-8
< Date: Tue, 26 Dec 2023 13:45:32 GMT
< Etag: "3147526947+ident"
< Expires: Tue, 02 Jan 2024 13:45:32 GMT
< Last-Modified: Thu, 17 Oct 2019 07:18:26 GMT
< Server: ECS (dcb/7F83)
< Vary: Accept-Encoding
< X-Cache: HIT
< Content-Length: 1256
<
<!doctype html>
<html>
<head>
    <title>Example Domain</title>
    ...

Linhas começando com * são mensagens informativas do próprio curl.
Linhas começando com > são cabeçalhos de requisição.
Linhas começando com < são cabeçalhos de resposta.
O conteúdo real segue os cabeçalhos de resposta.

Cabeçalhos Personalizados

Às vezes, você precisa enviar cabeçalhos específicos com sua requisição. Você pode usar a opção -H (ou --header) para isso. Vamos tentar definir um User-Agent personalizado:

curl -H "User-Agent: MyCustomClient/1.0" https://httpbin.org/user-agent

Este comando envia uma requisição para httpbin.org com um cabeçalho User-Agent personalizado. A resposta deve confirmar que seu User-Agent personalizado foi recebido:

{
  "user-agent": "MyCustomClient/1.0"
}

Seguindo Redirecionamentos

Por padrão, curl não segue redirecionamentos HTTP. Você pode usar a opção -L (ou --location) para fazê-lo seguir redirecionamentos. Vamos tentar:

curl -L http://github.com

Sem a opção -L, você obteria apenas uma resposta de redirecionamento. Com -L, curl segue o redirecionamento e mostra o conteúdo do destino final.

Vamos criar um arquivo no diretório de dados para praticar com essas opções:

curl -v -L -o data/redirect_example.txt http://github.com

Este comando:

  1. Usa o modo verboso (-v)
  2. Segue redirecionamentos (-L)
  3. Salva a saída em data/redirect_example.txt
  4. Requisita o conteúdo de github.com

Verifique se o arquivo foi criado:

ls -l data/redirect_example.txt

Você deve ver o arquivo listado com seus detalhes.

Métodos HTTP e Envio de Dados

curl suporta vários métodos HTTP além do método GET padrão. Nesta etapa, você aprenderá como usar diferentes métodos HTTP e enviar dados com suas requisições.

Usando o Método POST

O método POST é comumente usado para enviar dados a um servidor. Você pode usar a opção -X para especificar o método HTTP e a opção -d para fornecer os dados. Vamos tentar:

curl -X POST -d "name=John&age=25" https://httpbin.org/post

Este comando envia uma requisição POST com dados de formulário para httpbin.org. A resposta deve ecoar os dados que você enviou:

{
  "args": {},
  "data": "",
  "files": {},
  "form": {
    "age": "25",
    "name": "John"
  },
  "headers": {
    "Accept": "*/*",
    "Content-Length": "16",
    "Content-Type": "application/x-www-form-urlencoded",
    "Host": "httpbin.org",
    "User-Agent": "curl/7.81.0",
    "X-Amzn-Trace-Id": "Root=1-65b..."
  },
  "json": null,
  "origin": "your-ip-address",
  "url": "https://httpbin.org/post"
}

Enviando Dados JSON

Para enviar dados JSON, você precisa especificar o cabeçalho Content-Type. Execute:

curl -X POST -H "Content-Type: application/json" -d '{"name":"John","age":25}' https://httpbin.org/post

A resposta deve incluir seus dados JSON:

{
  "args": {},
  "data": "{\"name\":\"John\",\"age\":25}",
  "files": {},
  "form": {},
  "headers": {
    "Accept": "*/*",
    "Content-Length": "24",
    "Content-Type": "application/json",
    "Host": "httpbin.org",
    "User-Agent": "curl/7.81.0",
    "X-Amzn-Trace-Id": "Root=1-65b..."
  },
  "json": {
    "age": 25,
    "name": "John"
  },
  "origin": "your-ip-address",
  "url": "https://httpbin.org/post"
}

Usando Outros Métodos HTTP

curl suporta todos os métodos HTTP padrão. Vamos tentar uma requisição PUT:

curl -X PUT -d "data=example" https://httpbin.org/put

Você também pode tentar uma requisição DELETE:

curl -X DELETE https://httpbin.org/delete

Cada um desses comandos retornará uma resposta mostrando os detalhes da sua requisição.

Vamos salvar a saída de uma requisição POST em um arquivo:

curl -X POST -d "name=John&age=25" -o data/post_response.json https://httpbin.org/post

Verifique se o arquivo foi criado:

ls -l data/post_response.json

E verifique seu conteúdo:

cat data/post_response.json

Você deve ver a resposta JSON de httpbin.org, semelhante ao que foi mostrado anteriormente.

Download de Arquivos e Monitoramento de Progresso

curl é excelente para baixar arquivos da internet. Nesta etapa, você aprenderá como baixar arquivos e monitorar o progresso do download.

Download Básico de Arquivos

Para baixar um arquivo, você pode usar a opção -o que aprendemos anteriormente. Vamos baixar uma imagem de exemplo:

curl -o data/sample.jpg https://httpbin.org/image/jpeg

Este comando baixa uma imagem JPEG de httpbin.org e a salva como sample.jpg no diretório de dados.

Verifique se o arquivo foi baixado:

ls -l data/sample.jpg

Download com Barra de Progresso

Para downloads maiores, é útil ver o progresso. Você pode usar a opção -# para exibir uma barra de progresso:

curl -## -o data/sample_with_progress.jpg https://httpbin.org/image/jpeg

Você deve ver uma barra de progresso como esta:

######################################################################### 100.0%

Usando a Opção de Arquivo de Saída com Nome Automático

Se você quiser usar o mesmo nome de arquivo do arquivo remoto, pode usar a opção -O (O maiúsculo):

cd data
curl -O https://httpbin.org/image/jpeg
cd ..

Isso baixa o arquivo e o salva como jpeg (a última parte da URL) no diretório de dados.

Verifique se o arquivo foi baixado:

ls -l data/jpeg

Retomando Downloads Interrompidos

Se um download for interrompido, você pode retomá-lo usando a opção -C -:

curl -C - -o data/resume_example.jpg https://httpbin.org/image/jpeg

Isso diz ao curl para determinar automaticamente de onde retomar o download.

Limitando a Velocidade de Download

Você pode limitar a velocidade de download usando a opção --limit-rate:

curl --limit-rate 100K -o data/rate_limited.jpg https://httpbin.org/image/jpeg

Isso limita a velocidade de download a 100 KB/s.

Baixando Vários Arquivos

Você pode baixar vários arquivos com um único comando:

curl -o data/image1.jpg https://httpbin.org/image/jpeg -o data/image2.png https://httpbin.org/image/png

Isso baixa uma imagem JPEG e uma imagem PNG e as salva como image1.jpg e image2.png, respectivamente.

Verifique se ambos os arquivos foram baixados:

ls -l data/image1.jpg data/image2.png

Resumo

Neste laboratório, você aprendeu a usar curl, uma poderosa ferramenta de linha de comando para transferir dados com URLs. Agora você tem experiência prática com:

  1. Uso básico do curl para recuperar conteúdo da web
  2. Salvando a saída do curl em arquivos usando redirecionamento e a opção -o
  3. Usando opções avançadas do curl, como modo verbose (-v), cabeçalhos personalizados (-H) e seguindo redirecionamentos (-L)
  4. Trabalhando com diferentes métodos HTTP (GET, POST, PUT, DELETE) e enviando dados
  5. Baixando arquivos e monitorando o progresso do download

Essas habilidades são essenciais para muitas tarefas em administração de sistemas, desenvolvimento web, testes de API e scripts de automação. O comando curl é amplamente utilizado em vários campos técnicos e está disponível em praticamente todas as distribuições Linux, macOS e até mesmo Windows.

À medida que você continua sua jornada em Linux e redes, lembre-se de que o curl tem muitas mais opções e capacidades do que cobrimos neste laboratório. Você sempre pode consultar o manual do curl (man curl) para obter mais informações.