Hoja de referencia rápida de cURL

Comandos útiles de cURL con parámetros

Aquí tienes una hoja de referencia con los comandos de cURL más útiles y sus parámetros:

una persona con un letrero de cURL

La imagen anterior ha sido generada por Flux - modelo de IA de texto a imagen.

cURL es una herramienta esencial de línea de comandos para realizar peticiones HTTP y transferir datos. Para una guía integral de herramientas para desarrolladores que incluye Git, Docker, VS Code, bash, Terraform, PostgreSQL, GitHub Actions y la gestión de paquetes de Linux, consulta Herramientas para desarrolladores: La guía completa para flujos de trabajo de desarrollo moderno.

Uso básico de cURL

  • Descargar un archivo: curl http://example.com/file.zip -o file.zip
  • Descargar múltiples archivos: curl -O URL1 -O URL2
  • Seguir redirecciones: curl -L http://example.com/file
  • Mostrar solo las cabeceras: curl -I http://example.com

Autenticación

  • Autenticación básica: curl -u username:password http://example.com. Curl establece la cabecera Authorization: Basic con ese usuario y contraseña. La misma cabecera, construida con printf y base64, se encuentra en la hoja de referencia de codificación y decodificación en Base64.
  • Usar un archivo .netrc: curl --netrc-file .netrc http://example.com

Métodos HTTP

  • Petición POST: curl -X POST -d 'name=value' http://example.com
  • Petición PUT: curl -X PUT -d @file http://example.com
  • Método personalizado: curl -X METHOD http://example.com

Cabeceras y datos

  • Agregar una cabecera personalizada: curl -H "X-Header: Value" http://example.com
  • Enviar datos JSON: curl -H "Content-Type: application/json" -d '{"key":"value"}' http://example.com
  • Enviar datos de formulario: curl -F "key=value" -F "file=@localfile" http://example.com

Opciones SSL/TLS

  • Ignorar la verificación del certificado SSL: curl -k https://example.com
  • Usar un certificado de cliente: curl --cert cert.pem --key key.pem https://example.com

Proxy y redes

  • Usar un proxy: curl -x proxysever.server.com:PORT http://example.com
  • Limitar la velocidad de descarga: curl --limit-rate 1000B -O http://example.com/file

Control de salida

  • Modo silencioso: curl -s http://example.com
  • Modo detallado (verbose): curl -v http://example.com
  • Escribir la salida en un archivo: curl -o file.html http://example.com
  • Guardar con el nombre de archivo remoto: curl -O http://example.com/file.zip

Varios

  • Reanudar una descarga fallida: curl -C - -o partial_file.zip http://example.com/file.zip
  • Establecer un tiempo de espera: curl --connect-timeout 10 http://example.com
  • Usar un archivo de configuración: curl -K config_file http://example.com

Esta hoja de referencia cubre los comandos de cURL más comúnmente utilizados y sus parámetros, proporcionando una referencia rápida para diversas operaciones HTTP y transferencias de datos.

Comandos avanzados de cURL

Aquí tienes algunos comandos avanzados de curl para la depuración:

  1. Salida detallada: curl -v https://example.com Este comando proporciona información detallada sobre la solicitud y la respuesta, incluyendo cabeceras y detalles de la conexión.

  2. Volcado de trazas completo: curl --trace - https://example.com Esto imprime un volcado hexadecimal (hexdump) de todos los datos entrantes y salientes, ofreciendo una vista integral de toda la comunicación.

  3. Trazas con marcas de tiempo: curl --trace - --trace-time https://example.com Esto añade marcas de tiempo a la salida de la traza, lo que ayuda a analizar problemas relacionados con el tiempo.

  4. Imprimir solo las cabeceras de la respuesta: curl -s -o /dev/null -D - https://example.com Este comando muestra solo las cabeceras de la respuesta, útil para un análisis rápido de las cabeceras.

  5. Imprimir solo las cabeceras de la solicitud: curl -v -s -o /dev/null --stderr - https://example.com | grep '^>' Este comando complejo filtra solo las cabeceras de la solicitud, lo cual es útil para inspeccionar lo que se está enviando.

  6. Usar Pantheon Debugger: curl -I -H "Pantheon-Debug:1" https://example.com Este comando utiliza la cabecera de depuración de Pantheon para obtener información adicional sobre una solicitud, útil para sitios alojados en Pantheon.

  7. Forzar el protocolo HTTP/2: curl --http2 https://example.com Esto garantiza el uso del protocolo HTTP/2, que puede combinarse con -I para verificar el soporte de HTTP/2.

  8. Depurar con netcat: En una terminal: nc -l 1234 En otra: curl http://127.0.0.1:1234 Esto te permite ver exactamente lo que curl está enviando, útil para depurar cargas de datos (payloads).

Estos comandos avanzados proporcionan potentes capacidades de depuración, permitiendo a los desarrolladores inspeccionar diversos aspectos de las comunicaciones HTTP y solucionar problemas complejos.

Casos de uso comunes de cURL

curl es una herramienta de línea de comandos versátil con numerosas aplicaciones. A continuación se presentan algunos de los casos de uso más comunes para curl:

Interacciones web

  1. Descarga de archivos: curl puede descargar archivos desde URLs.
  2. Scraping web: curl puede recuperar el contenido de páginas web para fines de scraping.
  3. Pruebas de sitios web: curl es útil para verificar si un sitio web es accesible y recuperar su contenido.

Interacciones con APIs

  1. Envío de peticiones a APIs: curl admite diversos métodos HTTP (GET, POST, PUT, DELETE) para interactuar con APIs.
  2. Pruebas de puntos finales (endpoints) de API: curl ofrece una forma rápida de probar y depurar endpoints de API sin necesidad de un cliente de API dedicado.

Solución de problemas de red

  1. Comprobación de conectividad: curl se puede utilizar para verificar las conexiones de red y solucionar problemas.
  2. Pruebas de DNS: curl permite forzar servidores DNS específicos para solucionar problemas relacionados con DNS.
  3. Inspección de cabeceras: curl puede mostrar cabeceras HTTP, lo cual es útil para la depuración.

Transferencia de datos

  1. Operaciones FTP: curl admite transferencias de archivos usando el Protocolo de Transferencia de Archivos (FTP).
  2. Interacciones SMTP: curl se puede utilizar para enviar correos electrónicos mediante el Protocolo Simple de Transferencia de Correo (SMTP).

Seguridad y autenticación

  1. Conexiones SSL: curl admite conexiones seguras usando SSL/TLS.
  2. Autenticación: curl puede manejar diversos métodos de autenticación, incluyendo la autenticación básica y los certificados de cliente.

Desarrollo y depuración

  1. Simulación de diferentes métodos HTTP: curl permite a los desarrolladores probar diversos métodos HTTP con facilidad.
  2. Registro detallado (verbose): el modo verbose de curl proporciona información detallada sobre el ciclo de solicitud-respuesta, lo que ayuda en la depuración.

Estos casos de uso demuestran la flexibilidad de curl como herramienta para interacciones web, pruebas de APIs, solución de problemas de red y tareas de desarrollo.

Pruebas de rendimiento de sitios web con cURL

curl es una herramienta poderosa para probar el rendimiento de sitios web. A continuación te mostramos cómo puedes usarla para medir diversos aspectos de la velocidad de carga de un sitio web:

Prueba básica de rendimiento

Para obtener una medida simple del tiempo de carga de un sitio web, usa este comando:

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

Este comando mostrará el tiempo total que tardó en recuperar el sitio web[2].

Métricas de rendimiento detalladas

Para un análisis más integral, puedes usar curl para medir múltiples métricas de rendimiento:

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 proporciona un desglose de las diferentes etapas del proceso de carga, incluyendo el tiempo de búsqueda de DNS, el tiempo de conexión y el tiempo total[1].

Métricas avanzadas

Para un análisis aún más detallado, puedes incluir métricas adicionales:

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 incluye información sobre la versión de HTTP, el tamaño de la página y el código de respuesta[3].

Pruebas de rendimiento (Benchmarking) de múltiples peticiones

Para probar la consistencia o monitorear el rendimiento con el tiempo, puedes usar un bucle para realizar múltiples peticiones:

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

Esto ejecutará la prueba cinco veces y mostrará el tiempo total para cada solicitud[3].

Crear un script de prueba de rendimiento

Puedes crear un script de bash simple para automatizar estas pruebas y guardar los 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)"

Reemplaza “URL” con el sitio web que deseas probar. Este script guardará los resultados en un archivo con fecha[5].

Al usar estos comandos y scripts de curl, puedes medir y monitorear eficazmente el rendimiento del sitio web, lo que te ayuda a identificar posibles cuellos de botella y optimizar los tiempos de carga.

Enlaces útiles

Suscribirse

Recibe nuevas publicaciones sobre sistemas, infraestructura e ingeniería de IA.