Guide de développement de coroutine asynchrone : implémentation d'un système de file d'attente de courrier hautement simultané

Guide de développement de coroutine asynchrone : implémentation d'un système de file d'attente de courrier hautement simultané

Les applications Web modernes jouent un rôle important dans l'obtention d'une simultanéité, de performances et d'une évolutivité élevées. Dans ce cas, le modèle de programmation coroutine asynchrone est devenu une solution très populaire. Les opérations asynchrones impliquent souvent un grand nombre de tâches gourmandes en calculs ou en E/S.

Dans les applications backend, la file d'attente de courrier est un outil très utile qui peut nous aider à envoyer de grandes quantités d'e-mails de manière asynchrone et à rendre l'application plus robuste et fiable lors de l'envoi d'e-mails. Pour implémenter un système de file d'attente de courrier hautement concurrent, nous pouvons utiliser le modèle de coroutine asynchrone et utiliser le langage de programmation Python.

Cet article vous présentera comment utiliser des coroutines asynchrones pour développer un système de file d'attente de courrier à haute concurrence et fournira des exemples de code détaillés.

Étape 1 : Installez les bibliothèques Python requises

Avant de commencer à écrire du code, nous devons installer des bibliothèques Python tierces pour implémenter des coroutines asynchrones. Ces bibliothèques sont asyncio, aiosmtplib, aiordis.

Vous pouvez l'installer à l'aide de la commande suivante :

pip install asyncio aiosmtplib aioredis

Étape 2 : Connectez-vous au serveur Redis

Dans cet exemple, nous utiliserons Redis comme magasin de données. Redis est une base de données en mémoire hautes performances souvent utilisée pour la mise en cache et la file d'attente. Nous utiliserons la bibliothèque Python "aioredis" pour nous connecter au serveur Redis.

import asyncio
import aioredis

async def get_redis():
    return await aioredis.create_redis('redis://localhost')

Étape 3 : Créer une fonction d'envoi d'e-mails

Nous commencerons par définir la fonction asynchrone qui sera utilisée pour envoyer des e-mails. Pour cela nous utiliserons la librairie Python "aiosmtplib". Voici l'exemple de code pour la fonction email :

async def send_email(to_address, message):
    try:
        smtp_client = aiosmtplib.SMTP(hostname='smtp.gmail.com', port=587)
        await smtp_client.connect()
        await smtp_client.starttls()
        await smtp_client.login(user='your_email_address@gmail.com', password='your_password')
        await smtp_client.sendmail(from_addr='your_email_address@gmail.com', to_addrs=[to_address], msg=message)
        await smtp_client.quit()
        return True
    except:
        return False

Étape 4 : Créer une fonction asynchrone pour l'envoi d'e-mails

Maintenant, nous allons définir la fonction asynchrone qui récupérera l'e-mail de la file d'attente Redis et l'enverra. Voici l'exemple de code :

async def process_queue():
    redis = await get_redis()
    while True:
        message = await redis.lpop('email_queue')
        if message is not None:
            to_address, subject, body = message.decode('utf-8').split(',')
            email_message = f'Subject: {subject}

{body}'
            result = await send_email(to_address, email_message)
            if result:
                print(f'Sent email to {to_address}')
            else:
                await redis.rpush('email_queue', message)
        else:
            await asyncio.sleep(1)

Dans le code ci-dessus, nous avons défini une fonction asynchrone appelée "process_queue" qui fera ce qui suit :

1. Récupérez l'instance Redis depuis le serveur Redis à l'aide de la fonction "get_redis".
2. Récupérez le prochain e-mail de la file d'attente Redis en utilisant la méthode "lpop".
3. Si la file d'attente est vide, attendez 1 seconde (en utilisant la fonction "asyncio.sleep").
4. Divisez les e-mails en trois parties : adresse e-mail du destinataire, objet de l'e-mail et corps de l'e-mail.
5. Utilisez la fonction "send_email" pour envoyer des emails de manière asynchrone.
6. Si l'e-mail renvoie True, cela signifie que l'e-mail a été envoyé avec succès au destinataire.
7. Si l'e-mail renvoie False, remettez l'e-mail en file d'attente.

Étape 5 : Ajouter un e-mail à la file d'attente

Maintenant, nous allons définir une fonction qui sera utilisée pour ajouter des e-mails à la file d'attente Redis. Voici l'exemple de code :

async def add_email_to_queue(to_address, subject, body):
    redis = await get_redis()
    email_message = f'{to_address},{subject},{body}'.encode('utf-8')
    await redis.rpush('email_queue', email_message)

Dans le code ci-dessus, nous avons défini une fonction asynchrone appelée "add_email_to_queue" qui prend trois paramètres (adresse e-mail du destinataire, objet de l'e-mail et corps de l'e-mail) comme Entrée, et l'e-mail est codé et ajouté à la file d'attente Redis.

Étape 6 : Exécuter dans le programme principal

Nous sommes maintenant prêts à rassembler toutes les pièces et à exécuter le système de file d'attente de courrier dans le programme principal. Voici l'exemple de code :

if __name__ == '__main__':
    loop = asyncio.get_event_loop()
    tasks = [process_queue() for i in range(10)]
    loop.run_until_complete(asyncio.gather(*tasks))

Dans le code ci-dessus, nous utilisons la fonction "get_event_loop" pour obtenir la boucle d'événement asynchrone (également appelée boucle d'événement). Nous avons également créé des tâches locales pour chaque processeur de la file d'attente (de nombreux systèmes de messagerie utilisent plusieurs processeurs pour traiter les e-mails pour un débit élevé). Enfin, nous utilisons la fonction « rassembler » pour regrouper toutes les tâches et les exécuter.

Comme vous pouvez le constater, il est très simple de mettre en œuvre un système de file d'attente de courrier électronique avec des coroutines asynchrones. Nous pouvons utiliser la bibliothèque asynchrone intégrée de Python et des bibliothèques tierces pour implémenter des applications hautes performances et évolutives, ce qui nous permet de gérer plus efficacement les tâches informatiques à grande échelle ou les tâches gourmandes en E/S.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!