Lista de Atalhos do cURL

Comandos úteis do cUrl com parâmetros

Aqui está um guia de referência rápida para os comandos cURL mais úteis com seus parâmetros:

uma pessoa com um sinal de curl

A imagem acima foi gerada pelo Flux - modelo de IA de texto para imagem.

O cURL é uma ferramenta essencial de linha de comando para realizar solicitações HTTP e transferir dados. Para um guia completo sobre ferramentas de desenvolvedor, incluindo Git, Docker, VS Code, bash, Terraform, PostgreSQL, GitHub Actions e gerenciamento de pacotes Linux, consulte Ferramentas de Desenvolvedor: O Guia Completo para Fluxos de Trabalho de Desenvolvimento Moderno.

Uso Básico do cURL

  • Baixar um arquivo: curl http://example.com/file.zip -o file.zip
  • Baixar vários arquivos: curl -O URL1 -O URL2
  • Seguir redirecionamentos: curl -L http://example.com/file
  • Exibir apenas cabeçalhos: curl -I http://example.com

Autenticação

  • Autenticação básica: curl -u username:password http://example.com
  • Usar arquivo .netrc: curl --netrc-file .netrc http://example.com

Métodos HTTP

  • Solicitação POST: curl -X POST -d 'name=value' http://example.com
  • Solicitação PUT: curl -X PUT -d @file http://example.com
  • Método personalizado: curl -X METHOD http://example.com

Cabeçalhos e Dados

  • Adicionar cabeçalho personalizado: curl -H "X-Header: Value" http://example.com
  • Enviar dados JSON: curl -H "Content-Type: application/json" -d '{"key":"value"}' http://example.com
  • Enviar dados de formulário: curl -F "key=value" -F "file=@localfile" http://example.com

Opções SSL/TLS

  • Ignorar verificação de certificado SSL: curl -k https://example.com
  • Usar certificado do cliente: curl --cert cert.pem --key key.pem https://example.com

Proxy e Rede

  • Usar um proxy: curl -x proxysever.server.com:PORT http://example.com
  • Limitar taxa de download: curl --limit-rate 1000B -O http://example.com/file

Controle de Saída

  • Modo silencioso: curl -s http://example.com
  • Modo detalhado (verbose): curl -v http://example.com
  • Escrever saída em arquivo: curl -o file.html http://example.com
  • Salvar com nome de arquivo remoto: curl -O http://example.com/file.zip

Diversos

  • Retomar download falhado: curl -C - -o partial_file.zip http://example.com/file.zip
  • Definir tempo de espera (timeout): curl --connect-timeout 10 http://example.com
  • Usar arquivo de configuração: curl -K config_file http://example.com

Este guia de referência cobre os comandos cURL mais comumente usados e seus parâmetros, fornecendo uma referência rápida para várias operações HTTP e transferências de dados.

Comandos cURL Avançados

Aqui estão alguns comandos cURL avançados para depuração:

  1. Saída detalhada: curl -v https://example.com Este comando fornece informações detalhadas sobre a solicitação e a resposta, incluindo cabeçalhos e detalhes de conexão.

  2. Dump de rastreamento completo: curl --trace - https://example.com Isso exibe um hexdump de todos os dados de entrada e saída, oferecendo uma visão abrangente de toda a comunicação.

  3. Rastreamento com carimbos de data/hora: curl --trace - --trace-time https://example.com Isso adiciona carimbos de data/hora à saída do rastreamento, ajudando a analisar problemas relacionados a temporização.

  4. Imprimir apenas cabeçalhos de resposta: curl -s -o /dev/null -D - https://example.com Este comando mostra apenas os cabeçalhos de resposta, útil para análise rápida de cabeçalhos.

  5. Imprimir apenas cabeçalhos de solicitação: curl -v -s -o /dev/null --stderr - https://example.com | grep '^>' Este comando complexo filtra apenas os cabeçalhos de solicitação, útil para inspecionar o que está sendo enviado.

  6. Usar o Pantheon Debugger: curl -I -H "Pantheon-Debug:1" https://example.com Este comando usa o cabeçalho de Depuração do Pantheon para obter informações adicionais sobre uma solicitação, útil para sites hospedados no Pantheon.

  7. Forçar protocolo HTTP/2: curl --http2 https://example.com Isso garante o uso do protocolo HTTP/2, que pode ser combinado com -I para verificar o suporte ao HTTP/2.

  8. Depuração com netcat: Em um terminal: nc -l 1234 Em outro: curl http://127.0.0.1:1234 Isso permite que você veja exatamente o que o curl está enviando, útil para depuração de payloads.

Estes comandos avançados fornecem poderosas capacidades de depuração, permitindo que os desenvolvedores inspecionem vários aspectos das comunicações HTTP e resolvam problemas complexos.

Casos de uso comuns do cURL

O curl é uma ferramenta de linha de comando versátil com inúmeras aplicações. Aqui estão alguns dos casos de uso mais comuns para o curl:

Interações Web

  1. Baixando arquivos: o curl pode baixar arquivos de URLs.
  2. Web scraping: o curl pode recuperar o conteúdo de páginas web para fins de raspagem.
  3. Testando sites: o curl é útil para verificar se um site está acessível e recuperar seu conteúdo.

Interações com API

  1. Envio de solicitações de API: o curl suporta vários métodos HTTP (GET, POST, PUT, DELETE) para interagir com APIs.
  2. Testando endpoints de API: o curl oferece uma maneira rápida de testar e depurar endpoints de API sem precisar de um cliente de API dedicado.

Solução de Problemas de Rede

  1. Verificando conectividade: o curl pode ser usado para verificar conexões de rede e solucionar problemas.
  2. Testando DNS: o curl permite forçar servidores DNS específicos para solucionar problemas relacionados ao DNS.
  3. Inspecionando cabeçalhos: o curl pode exibir cabeçalhos HTTP, o que é útil para depuração.

Transferência de Dados

  1. Operações FTP: o curl suporta transferências de arquivos usando o Protocolo de Transferência de Arquivos (FTP).
  2. Interações SMTP: o curl pode ser usado para enviar e-mails via Simple Mail Transfer Protocol (SMTP).

Segurança e Autenticação

  1. Conexões SSL: o curl suporta conexões seguras usando SSL/TLS.
  2. Autenticação: o curl pode lidar com vários métodos de autenticação, incluindo autenticação básica e certificados de cliente.

Desenvolvimento e Depuração

  1. Simulando diferentes métodos HTTP: o curl permite que os desenvolvedores testem vários métodos HTTP facilmente.
  2. Log detalhado: o modo detalhado (verbose) do curl fornece informações detalhadas sobre o ciclo de solicitação-resposta, auxiliando na depuração.

Estes casos de uso demonstram a flexibilidade do curl como ferramenta para interações web, teste de APIs, solução de problemas de rede e tarefas de desenvolvimento.

Teste de desempenho de sites com cURL

O curl é uma ferramenta poderosa para testar o desempenho de sites. Veja como você pode usá-lo para medir vários aspectos da velocidade de carregamento de um site:

Teste de Desempenho Básico

Para obter uma medida simples do tempo de carregamento de um site, use este comando:

curl -o /dev/null -s -w "Total Time: %{time_total}s\n" "https://example.com"

Este comando exibirá o tempo total que levou para buscar o site[2].

Métricas de Desempenho Detalhadas

Para uma análise mais abrangente, você pode usar o curl para medir múltiplas métricas de desempenho:

curl -s -w 'Testing Website Response Time for :%{url_effective}\n\nLookup Time:\t\t%{time_namelookup}\nConnect Time:\t\t%{time_connect}\nPre-transfer Time:\t%{time_pretransfer}\nStart-transfer Time:\t%{time_starttransfer}\n\nTotal Time:\t\t%{time_total}\n' -o /dev/null https://example.com

Este comando fornece uma divisão das diferentes etapas no processo de carregamento, incluindo tempo de pesquisa DNS, tempo de conexão e tempo total[1].

Métricas Avançadas

Para uma análise ainda mais detalhada, você pode incluir métricas adicionais:

curl -o /dev/null -w "HTTP Version: %{http_version}\nPage Size: %{size_download} bytes\nResponse Code: %{response_code}\nDNS Lookup: %{time_namelookup} sec\nConnect Time: %{time_connect} sec\nTime to First Byte: %{time_starttransfer} sec\nTotal Time: %{time_total} sec\n" -s https://example.com

Este comando inclui informações sobre a versão HTTP, tamanho da página e código de resposta[3].

Benchmarking de Múltiplas Solicitações

Para testar a consistência ou monitorar o desempenho ao longo do tempo, você pode usar um loop para fazer várias solicitações:

for i in {1..5}; do curl -o /dev/null -s -w "Request $i Total Time: %{time_total}\n" https://example.com; done

Isso executará o teste cinco vezes e mostrará o tempo total para cada solicitação[3].

Criando um Script de Teste de Desempenho

Você pode criar um script bash simples para automatizar esses testes e salvar os resultados:

#!/bin/bash
curl -s -w 'Testing Website Response Time for :%{url_effective}\n\nLookup Time:\t\t%{time_namelookup}\nConnect Time:\t\t%{time_connect}\nPre-transfer Time:\t%{time_pretransfer}\nStart-transfer Time:\t%{time_starttransfer}\n\nTotal Time:\t\t%{time_total}\n' -o /dev/null URL > webspeedtest_"$(date)"

Substitua “URL” pelo site que você deseja testar. Este script salvará os resultados em um arquivo com carimbo de data/hora[5].

Ao usar esses comandos e scripts do curl, você pode medir e monitorar efetivamente o desempenho do site, ajudando a identificar potenciais gargalos e otimizar os tempos de carregamento.

Assinar

Receba novos artigos sobre sistemas, infraestrutura e engenharia de IA.