¿Cómo envío un archivo como archivo adjunto de correo electrónico usando la línea de comando de Linux?

StackOverflow https://stackoverflow.com/questions/17359

  •  08-06-2019
  •  | 
  •  

Pregunta

Creé un script que se ejecuta todas las noches en mi servidor Linux y que usa mysqldump hacer una copia de seguridad de cada una de mis bases de datos MySQL en archivos .sql y empaquetarlas como un archivo .tar comprimido.El siguiente paso que quiero lograr es enviar ese archivo tar por correo electrónico a un servidor de correo electrónico remoto para su custodia.Pude enviar el script sin formato en el cuerpo de un correo electrónico canalizando el archivo de texto de respaldo a mailx al igual que:

$ cat mysqldbbackup.sql | mailx backup@email.com

cat hace eco del texto del archivo de copia de seguridad que se canaliza al mailx programa con la dirección de correo electrónico del destinatario pasada como argumento.

Si bien esto logra lo que necesito, creo que podría ser un paso mejor. ¿Hay alguna forma, mediante scripts de shell o de otro modo, de enviar el archivo .tar comprimido a un mensaje de correo electrónico saliente como un adjunto? Esto evitaría tener que lidiar con mensajes de correo electrónico muy largos que contienen datos de encabezado y que a menudo tienen problemas de ajuste de palabras, etc.

¿Fue útil?

Solución

Ninguno de los perros callejeros funcionó para mí.Pensaba que la dirección de correo electrónico era parte del archivo adjunto.Tuve que hacer:

echo "This is the message body" | mutt -a "/path/to/file.to.attach" -s "subject of message" -- recipient@domain.com

Otros consejos

O, en su defecto, perro callejero:

gzip -c mysqldbbackup.sql | uuencode mysqldbbackup.sql.gz  | mail -s "MySQL DB" backup@email.com

De mirar man mailx, el programa mailx no tiene la opción de adjuntar un archivo.Podrías utilizar otro programa como mutt.

echo "This is the message body" | mutt -a file.to.attach -s "subject of message" recipient@domain.com

Las opciones de línea de comando para mutt se pueden mostrar con mutt -h.

Dependiendo de su versión de Linux, puede llamarse correo.Para citar a @David arriba:

mail -s "Backup" -a mysqldbbackup.sql backup@email.com < message.txt

o también:

cat message.txt | mail -s "Backup" -a mysqldbbackup.sql backup@email.com

Yo uso mpack.

mpack -s subject file user@example.com

Desafortunadamente, mpack no reconoce '-' como alias para stdin.Pero lo siguiente funciona y se puede incluir fácilmente en un alias (shell) o un script:

mpack -s subject /dev/stdin loser@example.com < file

Yo uso SendEmail, que fue creado para este escenario.Está empaquetado para Ubuntu, así que supongo que está disponible.

sendemail -f sender@some.where -t receiver@some.place -m "Here are your files!" -a file1.jpg file2.zip

http://caspian.dotconf.net/menu/Software/SendEmail/

 echo 'These are contents of my mail' | mailx -s 'This is my email subject' -a /path/to/attachment_file.log email_id@example.com

Puedes usar chucho para enviar el correo electrónico con el archivo adjunto

mutt -s "Backup" -a mysqldbbackup.sql backup@email.com < message.txt

Una vez escribí esta función para ksh en Solaris (usa Perl para la codificación base64): 

# usage: email_attachment to cc subject body attachment_filename
email_attachment() {
    to="$1"
    cc="$2"
    subject="$3"
    body="$4"
    filename="${5:-''}"
    boundary="_====_blah_====_$(date +%Y%m%d%H%M%S)_====_"
    {
        print -- "To: $to"
        print -- "Cc: $cc"
        print -- "Subject: $subject"
        print -- "Content-Type: multipart/mixed; boundary=\"$boundary\""
        print -- "Mime-Version: 1.0"
        print -- ""
        print -- "This is a multi-part message in MIME format."
        print -- ""
        print -- "--$boundary"
        print -- "Content-Type: text/plain; charset=ISO-8859-1"
        print -- ""
        print -- "$body"
        print -- ""
        if [[ -n "$filename" && -f "$filename" && -r "$filename" ]]; then
            print -- "--$boundary"
            print -- "Content-Transfer-Encoding: base64"
            print -- "Content-Type: application/octet-stream; name=$filename"
            print -- "Content-Disposition: attachment; filename=$filename"
            print -- ""
            print -- "$(perl -MMIME::Base64 -e 'open F, shift; @lines=<F>; close F; print MIME::Base64::encode(join(q{}, @lines))' $filename)"
            print -- ""
        fi
        print -- "--${boundary}--"
    } | /usr/lib/sendmail -oi -t
}

Envíe un correo electrónico con cuerpo de texto sin formato con un archivo adjunto de texto sin formato con mailx:

(
  /usr/bin/uuencode attachfile.txt myattachedfilename.txt; 
  /usr/bin/echo "Body of text"
) | mailx -s 'Subject' youremail@gmail.com

A continuación se muestra el mismo comando que el anterior, sin las nuevas líneas.

( /usr/bin/uuencode /home/el/attachfile.txt myattachedfilename.txt; /usr/bin/echo "Body of text" ) | mailx -s 'Subject' youremail@gmail.com

Asegúrate de tener un archivo /home/el/attachfile.txt definido con este contenido:

<html><body>
Government discriminates against programmers with cruel/unusual 35 year prison
sentences for making the world's information free, while bankers that pilfer 
trillions in citizens assets through systematic inflation get the nod and 
walk free among us.
</body></html>

Si no tienes uuencode lee esto: https://unix.stackexchange.com/questions/16277/how-do-i-get-uuencode-to-work

En Linux, envíe un correo electrónico con cuerpo HTML con un archivo PDF adjunto con sendmail:

Asegúrate de tener ksh instalado: yum info ksh

Asegúrate de tener sendmail instalado y configurado.

Asegúrate de tener uuencode instalado y disponible: https://unix.stackexchange.com/questions/16277/how-do-i-get-uuencode-to-work

Crea un nuevo archivo llamado test.sh y colóquelo en su directorio personal: /home/el

Pon el siguiente código en test.sh:

#!/usr/bin/ksh
export MAILFROM="el@defiant.com"
export MAILTO="youremail@gmail.com"
export SUBJECT="Test PDF for Email"
export BODY="/home/el/email_body.htm"
export ATTACH="/home/el/pdf-test.pdf"
export MAILPART=`uuidgen` ## Generates Unique ID
export MAILPART_BODY=`uuidgen` ## Generates Unique ID

(
 echo "From: $MAILFROM"
 echo "To: $MAILTO"
 echo "Subject: $SUBJECT"
 echo "MIME-Version: 1.0"
 echo "Content-Type: multipart/mixed; boundary=\"$MAILPART\""
 echo ""
 echo "--$MAILPART"
 echo "Content-Type: multipart/alternative; boundary=\"$MAILPART_BODY\""
 echo ""
 echo "--$MAILPART_BODY"
 echo "Content-Type: text/plain; charset=ISO-8859-1"
 echo "You need to enable HTML option for email"
 echo "--$MAILPART_BODY"
 echo "Content-Type: text/html; charset=ISO-8859-1"
 echo "Content-Disposition: inline"
 cat $BODY
 echo "--$MAILPART_BODY--"

 echo "--$MAILPART"
 echo 'Content-Type: application/pdf; name="'$(basename $ATTACH)'"'
 echo "Content-Transfer-Encoding: uuencode"
 echo 'Content-Disposition: attachment; filename="'$(basename $ATTACH)'"'
 echo ""
 uuencode $ATTACH $(basename $ATTACH)
 echo "--$MAILPART--"
) | /usr/sbin/sendmail $MAILTO

Cambie las variables de exportación en la parte superior de test.sh para reflejar su dirección y nombres de archivos.

Descargue un documento pdf de prueba y colóquelo /home/el llamado pdf-test.pdf

Cree un archivo llamado /home/el/email_body.htm y coloque esta línea en él:

<html><body><b>this is some bold text</b></body></html>

Asegúrese de que el archivo pdf tenga suficientes permisos 755.

Ejecute el script ./test.sh

Revise su bandeja de entrada de correo electrónico, el texto debe estar en formato HTML y el archivo pdf debe interpretarse automáticamente como un archivo binario.Tenga cuidado de no utilizar esta función más de 15 veces al día, incluso si se envía los correos electrónicos a usted mismo, los filtros de spam en Gmail pueden incluir en la lista negra un dominio que arroja correos electrónicos sin darle la opción de dejarlos pasar.Y descubrirá que esto ya no funciona, o solo deja pasar el archivo adjunto, o el correo electrónico no llega en absoluto.Si tienes que hacer muchas pruebas sobre esto, distribúyelas durante días o serás etiquetado como spammer y esta función ya no funcionará.

Hay varias respuestas aquí sugiriendo mail o mailx Así que esto es más bien un contexto para ayudarle a interpretarlos en contexto.

Notas históricas

Los orígenes de Unix mail Nos remontamos a las brumas de la historia temprana de Bell Labs Unix™ (¿1969?), y probablemente no podemos esperar entrar aquí en su genealogía completa.Baste decir que hay muchos programas que heredan código de o reimplementan (o heredan código de una reimplementación de) mail y que no existe una única base de código que pueda identificarse sin ambigüedades como "el" mail.

Sin embargo, uno de los aspirantes a ese puesto es sin duda "Berkeley Mail", que originalmente se llamaba Mail con una M mayúscula en 2BSD (1978);pero en 3BSD (1979), reemplazó la minúscula mail comando también, lo que lleva a una nueva confusión.SVR3 (1986) incluyó un derivado que se denominó mailx.El x presumiblemente se agregó para hacerlo único y distinto;pero esto también ha sido copiado, reimplementado y mutilado, de modo que no existe una única versión individual que sea definitiva.

En el pasado, el de facto El estándar para enviar archivos binarios por correo electrónico era uuencode.Todavía existe, pero tiene numerosos problemas de usabilidad;Si es posible, debe enviar archivos adjuntos MIME, a menos que se esfuerce específicamente por poder comunicarse con finales de la década de 1980.

MÍMICA se introdujo a principios de la década de 1990 para resolver varios problemas con el correo electrónico, incluida la compatibilidad con varios tipos de contenido distintos del texto sin formato en un solo conjunto de caracteres que en realidad solo es adecuado para un subconjunto de inglés (y, según nos dicen, hawaiano) .Esto introdujo soporte para mensajes de varias partes, internacionalización, tipos de contenido enriquecido, etc., y rápidamente ganó fuerza a lo largo de la década de 1990.

(El Reliquia de familia mail/mailx notas de historia fueron de gran ayuda al redactar esto y ciertamente vale la pena leerlos si te gustan ese tipo de cosas).

Ofertas actuales

A partir de 2018, Debian tiene tres paquetes que incluyen un mail o mailx dominio.(Puedes buscar Provides: mailx.)

debian$ aptitude search ~Pmailx
i   bsd-mailx                       - simple mail user agent
p   heirloom-mailx                  - feature-rich BSD mail(1)
p   mailutils                       - GNU mailutils utilities for handling mail

(No estoy destacando a Debian como una recomendación;es lo que uso, así que estoy familiarizado con él;y proporciona un medio para distinguir las diversas alternativas sin ambigüedades haciendo referencia a sus respectivos nombres de paquetes.Obviamente también es la distribución de la que Ubuntu obtiene estos paquetes).

Con estas preocupaciones, si necesita que su código sea portátil y puede depender de un paquete algo complejo, la forma sencilla de enviar archivos adjuntos MIME de forma portátil es usar mutt.

Otra alternativa - swaks (Navaja suiza para SMTP).

swaks -tls \
    --to ${MAIL_TO} \
    --from ${MAIL_FROM} \
    --server ${MAIL_SERVER} \
    --auth LOGIN \
    --auth-user ${MAIL_USER} \
    --auth-password ${MAIL_PASSWORD} \
    --header "Subject: $MAIL_SUBJECT" \
    --header "Content-Type: text/html; charset=UTF-8" \
    --body "$MESSAGE" \
    --attach mysqldbbackup.sql

metamail tiene la herramienta metasend

metasend -f mysqlbackup.sql.gz -t backup@email.com -s Backup -m application/x-gzip -b

solía 

echo "Start of Body" && uuencode log.cfg readme.txt | mail -s "subject" "a@b.c"

y esto funcionó bien para mí....

mailx tiene un -a opción ahora para archivos adjuntos.

Normalmente sólo uso el comando de correo en RHEL.Probé mailx y es bastante eficiente.

mailx -s "Sending Files" -a First_LocalConfig.conf -a
Second_LocalConfig.conf Recipient@myemail.com

This is the content of my msg.

.

el camino más corto para mí es

file=filename_or_filepath;uuencode $file $file|mail -s "optional subject" email_address

así que para tu ejemplo será

file=your_sql.log;gzip -c $file;uuencode ${file}.gz ${file}|mail -s "file with magnets" ph.gachoud@gmail.com

Lo bueno es que puedo recordarlo con Ctrl+r para enviar otro archivo...

Desde la máquina fuente

mysqldump --defaults-extra-file=sql.cnf database | gzip | base64 | mail me@myemail.com

En la máquina de destino.Guarde el cuerpo del correo recibido como db.sql.gz.b64;entonces..

base64 -D -i db.sql.gz.b64 | gzip -d | mysql --defaults-extra-file=sql.cnf

usando el comando mailx

 echo "Message Body Here" | mailx -s "Subject Here" -a file_name user@example.com

usando enviar correo 

#!/bin/ksh

fileToAttach=data.txt

`(echo "To: user@company.com"
  echo "Cc: user@company.com"
  echo "From: Application"
  echo "Subject: your subject"
  echo  your body
  uuencode $fileToAttach $fileToAttach
  )| eval /usr/sbin/sendmail -t `;

Sólo para agregar mis 2 centavos, escribiría mi propio script PHP:

http://php.net/manual/en/function.mail.php

Hay muchas formas de realizar el archivo adjunto en los ejemplos de esa página.

No es un método para enviar correo electrónico, pero puedes usar un servidor Git en línea (p. ej.Bitbucket o un servicio similar) para eso.

De esta manera, puedes usar git push Los comandos, y todas las versiones se almacenarán de forma comprimida y organizada.

Así es como lo hago con un archivo de registro grande en CentOS:

MAIL="`whereis mail | awk '{print $2}'`"
WHOAMI="`whoami`"
HOSTNAME="`hostname`"
EMAIL"your@email.address"
LOGDIR="/var/log/aide"
LOGNAME="`basename "$0"`_`date "+%Y%m%d_%H%M"`"
# Arhiveerime ning kui hästi, saadame edasi:
/bin/tar -zcvf ${LOGDIR}/${LOGNAME}.tgz "${LOGDIR}/${LOGNAME}.log" > /dev/null 2>&1
if [ $? -eq 0 ]; then
    cd ${LOGDIR}
    # This works too. The message content will be taken from text file below
    # echo 'Hello!' >/root/scripts/audit_check.sh.txt
    # echo "Arhiivifail manuses" | ${MAIL} -s "${HOSTNAME} Aide report" -q /root/scripts/audit_check.sh.txt -a ${LOGNAME}.tgz -S from=${WHOAMI}@${HOSTNAME} ${EMAIL}
    echo "Arhiivifail manuses" | ${MAIL} -s "${HOSTNAME} Aide report" -a ${LOGNAME}.tgz -S from=${WHOAMI}@${HOSTNAME} ${EMAIL}
    /bin/rm "${LOGDIR}/${LOGNAME}.log"
fi

Si el archivo es de texto, puedes enviarlo más fácilmente en el cuerpo como:

sendmail recipient@example.com < message.txt

Mailutils hace que esto sea pan comido

echo "Body" | mail.mailutils -M -s "My Subject" -A attachment.pdf mail@example.org
  • -A file adjunta un archivo
  • -M habilita MIME, para que pueda tener un archivo adjunto y un cuerpo de texto sin formato.

Si aún no está instalado, ejecute

sudo apt install mailutils

Una cosa más sobre mutt:De forma predeterminada, utiliza su dirección y nombre en el campo "De:".Si no es lo que necesita, puede crear un archivo muttrc alternativo que contenga una cadena como esta:set from="Mi demonio de correo"

Utilice este archivo con -F opción de línea de comando.

Si mutt no funciona o no está instalado, intente esto:

*#!/bin/sh

FilePath=$1
FileName=$2
Message=$3
MailList=$4

cd $FilePath

Rec_count=$(wc -l < $FileName)
if [ $Rec_count -gt 0 ]
then
(echo "The attachment contains $Message" ; uuencode $FileName $FileName.csv ) | mailx -s "$Message" $MailList
fi*
Licenciado bajo: CC-BY-SA con atribución
No afiliado a StackOverflow
scroll top