Charger des tables AWS-RDS / PostgreSQL avec AWS-Lambda + Python

Charger des tables AWS-RDS / PostgreSQL avec AWS-Lambda + Python

introduction

`Ceci est un article sur l'environnement Mac, mais la procédure est la même pour l'environnement Windows. Veuillez lire et essayer la partie dépendant de l'environnement. ''

Objectif

Après avoir lu cet article jusqu'au bout, vous pourrez:

Environnement d'exécution

Code source

Je pense que vous pouvez approfondir votre compréhension en suivant réellement le contenu de l'implémentation et le code source. Veuillez l'utiliser par tous les moyens.

GitHub

Articles Liés

• Psycopg
• Effectuer régulièrement un scraping WEB avec AWS-Lambda + Python + Cron

Fonctionnalités d'AWS-Lambda

Ce service est un système de paiement à l'utilisation. Notez s'il vous plaît.

• Fonctionnalités
• Prix

Flux global

1. Écrivez du code Python
2. Créez une fonction Lambda
3. Définissez les variables d'environnement
4. Définissez les paramètres de base
5. Configurer le VPC

1. Écrivez du code Python

codage

app/lambda_function.py

"""app/lambda_function.py
"""

import os
import sys

import psycopg2


class Database():
    """Database
    """
    class Parameter():
        """Parameter
        """

        def __init__(self, host, port, dbname, table, user, password, query):
            self.host = host
            self.port = port
            self.dbname = dbname
            self.table = table
            self.user = user
            self.password = password
            self.query = query

    def __init__(self, param):
        self.db = param
        self.header = tuple()
        self.records = list()
        self.counts = int()

    def _connection(self):
        """_connection
        """
        print('connect to db: {}/{}'.format(self.db.host, self.db.dbname))
        return psycopg2.connect(
            host=self.db.host,
            port=self.db.port,
            dbname=self.db.dbname,
            user=self.db.user,
            password=self.db.password
        )

    def query(self):
        """query
        """
        with self._connection() as conn:
            with conn.cursor() as cursor:
                try:
                    cursor.execute(self.db.query)
                    self.header = cursor.description
                    self.records = cursor.fetchall()
                    self.counts = len(self.records)
                except psycopg2.Error as e:
                    print(e)
                    sys.exit()
        return True


def lambda_handler(event, context):
    """lambda_handler
    """
    print('event: {}'.format(event))
    print('context: {}'.format(context))

    param = Database.Parameter(
        host=os.getenv('DB_HOST', ''),
        port=os.getenv('DB_PORT', ''),
        dbname=os.getenv('DB_DBNAME', ''),
        table=os.getenv('DB_TABLE', ''),
        user=os.getenv('DB_USER', ''),
        password=os.getenv('DB_PASSWORD', ''),
        query=os.getenv('DB_QUERY', '')
    )

    db = Database(param=param)
    db.query()

    return {
        'status_code': 200,
        'records': str(db.records),
        'counts': db.counts
    }


if __name__ == '__main__':
    print(lambda_handler(event=None, context=None))

2. Créez une fonction Lambda

Exécutez régulièrement le scraping WEB avec AWS-Lambda + Python + Cron](https://qiita.com/nsuhara/items/0d36600511fc162827f6) et effectuez jusqu'à zip upload

3. Définissez les variables d'environnement

Variable d'environnement

1. Définir à partir de ʻEdit dans la section Variables d'environnement`

`{} est différent pour chaque environnement. ''

4. Définissez les paramètres de base

configuration de base

1. Définir depuis ʻEdit dans la section Paramètres de base`
2. Le délai d'expiration peut être réglé jusqu'à «15 minutes 0 secondes»
3. La mémoire peut être configurée jusqu'à 3008 Mo

5. Configurer le VPC

VPC

1. Définir à partir de ʻEdit dans la section VPC`
2. Définissez «VPC», «sous-réseau», «groupe de sécurité»

Doit correspondre aux paramètres RDS