Cómo enviar un correo electrónico con boto y SES

    Introducción

    Prácticamente todas las aplicaciones y sitios web basados ​​en el usuario necesitan enviar un correo electrónico al usuario en algún momento, por lo que eventualmente tendrá que lidiar con el alegre mundo del correo electrónico programático. Están apareciendo bastantes servicios para ayudarlo con esto, pero dado que cada aplicación tiene sus propios requisitos únicos, pocos de estos servicios hacen el trabajo adecuadamente.

    Entonces, habiendo enfrentado el problema varias veces (y en algunos idiomas), decidí escribir esta breve publicación sobre cómo enviar correos electrónicos con boto y SES. La biblioteca boto es un contenedor muy agradable para Python que lo ayuda a interactuar con la API de AWS. Para ver algunas de sus capacidades, consulte mi otro artículo de boto sobre cómo cargar un archivo en s3.

    Te puede interesar:Git: clonar un repositorio

    Preparar

    Antes de que realmente pueda hacer algo, necesitará una cuenta de AWS (obviamente) junto con la clave de acceso y la clave secreta de su cuenta, que se utilizará para autenticarse con los servidores SES. Hay un algunas formas diferentes puede usar las claves para autenticarse, pero aquí solo las pasaremos al connect_to_region método proporcionado por boto.

    A continuación, deberá verificar con SES una dirección de correo electrónico (una dirección de Gmail funciona bien) o un dominio de su propiedad. Si solo está probando esta función, le sugiero que verifique solo una dirección de correo electrónico, ya que es un poco más rápido. Todo lo que necesita hacer es hacer clic en un enlace en el correo electrónico de verificación que le envían, en lugar de agregar registros TXT a su archivo de zona para verificar un dominio.

    Te puede interesar:Git: crear un nuevo repositorio

    Si está utilizando SES por primera vez y su aplicación deberá enviar un gran volumen de correos electrónicos, es posible que deba enviar una solicitud para aumentar su Cuota de envío. Su cuenta de SES se coloca inicialmente en una ‘caja de arena’, lo que significa que solo puede enviar 200 correos electrónicos en un período de 24 horas. Una vez que haya solicitado con éxito aumentar sus límites de envío, debería poder enviar muchos más (me aprobaron 50,000 por día, que es mucho más de lo que necesito).

    El código

    Una vez que haya realizado la configuración inicial que mencioné anteriormente, debería poder usar el código a continuación para enviar correos electrónicos.

    Te puede interesar:Preguntas de la entrevista de programación de listas vinculadas
    import boto.ses
    
    AWS_ACCESS_KEY = 'YOUR-ACCESS-KEY-HERE'
    AWS_SECRET_KEY = 'YOUR-SECRET-KEY-HERE'
    
    class Email(object):
        def __init__(self, to, subject):
            self.to = to
            self.subject = subject
            self._html = None
            self._text = None
            self._format="html"
    
        def html(self, html):
            self._html = html
    
        def text(self, text):
            self._text = text
    
        def send(self, from_addr=None):
            body = self._html
    
            if isinstance(self.to, basestring):
                self.to = [self.to]
            if not from_addr:
                from_addr="[email protected]"
            if not self._html and not self._text:
                raise Exception('You must provide a text or html body.')
            if not self._html:
                self._format="text"
                body = self._text
    
            connection = boto.ses.connect_to_region(
                'us-east-1',
                aws_access_key_id=AWS_ACCESS_KEY, 
                aws_secret_access_key=AWS_SECRET_KEY
            )
    
            return connection.send_email(
                from_addr,
                self.subject,
                None,
                self.to,
                format=self._format,
                text_body=self._text,
                html_body=self._html
            )
    

    Para usar este código, todo lo que necesita hacer es esto:

    email = Email(to='[email protected]', subject="You are HTML Awesome")
    email.text('This is a text body. Foo bar.')
    email.html('<html><body>This is a text body. <strong>Foo bar.</strong></body></html>')  # Optional
    email.send()
    

    los email.html() la llamada es opcional. Si incluye tanto texto como HTML en su correo electrónico, ambos se incluirán en el MÍMICA y el cliente de correo electrónico mostrará el formato que sea compatible o preferido por el usuario.

    Te puede interesar:Git: eliminar un archivo

    Usar plantillas de correo electrónico

    Si quiere ser realmente elegante, intente usar un motor de plantillas. En lugar de pasar la cadena del cuerpo del correo electrónico directamente, podemos cargarla desde una plantilla, de forma muy similar a como lo haría con una página HTML en un marco web como Django.

    Aquí usamos el Jinja2 motor de plantillas para manejar la carga y la representación de la plantilla:

    Te puede interesar:Git: diferencia entre ‘git fetch’ y ‘git pull’
    import boto.ses
    from jinja2 import Environment, PackageLoader
    
    # Loads templates from the yourapp.templates folder
    env = Environment(loader=PackageLoader('yourapp', 'templates'))
    
    AWS_ACCESS_KEY = 'YOUR-ACCESS-KEY-HERE'
    AWS_SECRET_KEY = 'YOUR-SECRET-KEY-HERE'
    
    class Email(object):
        def __init__(self, to, subject):
            self.to = to
            self.subject = subject
            self._html = None
            self._text = None
    
        def _render(self, filename, context):
            template = env.get_template(filename)
            return template.render(context)
    
        def html(self, filename, context):
            self._html = self._render(filename, context)
    
        def text(self, filename, context):
            self._text = self._render(filename, context)
    
        def send(self, from_addr=None):
            # Same as before...
    

    Nota: Para el código de producción, no ponga sus claves de seguridad de AWS directamente en su código. En su lugar, use algo como variables ambientales.

    El uso de este código es similar al anterior, pero en su lugar simplemente pasaremos el nombre de archivo de la plantilla y el contexto desde el cual se completará la plantilla:

    Te puede interesar:Git: Switch Branch
    email = Email(to='[email protected]', subject="OMG an Email!")
    ctx = {'username': user.username}
    email.text('email.txt', ctx)
    email.html('email.html', ctx)  # Optional
    email.send()
    

    Ahora puede crear y procesar correos electrónicos HTML fácilmente como lo hace con las páginas web.

    Conclusión

    Esperamos que este breve tutorial te haya resultado útil. El código aquí debería ser bueno para la mayoría de los casos de uso, aunque puede avanzar aún más agregando Cc, Bcc, direcciones de respuesta, rutas de retorno o incluso archivos adjuntos.

    Todas estas funciones adicionales que acabo de mencionar, excepto los archivos adjuntos, pueden ser manejadas por el send_email función. Para enviar archivos adjuntos, deberá utilizar el nivel inferior send_raw_email función, que requiere que usted mismo cree el mensaje MIME. No se preocupe, eso no es demasiado difícil gracias a al paquete de Python de correo electrónico, pero lo guardaremos para otro artículo.

    ¿Te resultó útil? ¿Encontraste un error? ¡Házmelo saber en los comentarios!

     

    Rate this post