[PYTHON] Ich wollte die Google-Tabelle mit AWS Lambda betreiben, also habe ich es versucht [Teil 2]

Überblick

Dies ist eine Fortsetzung des vorherigen Artikels. Das letzte Mal habe ich die untere Hälfte erstellt, also werde ich dieses Mal die obere Hälfte erstellen

Serverlose Framework-Umgebung

Betriebsumgebung

npm (6.14.8): Wenn es nicht alt ist ... serverlos (2.8.0): Wenn es sich um eine 2.x.x-Serie handelt Python (3.8.2): Wenn es sich um eine 3.8-Serie handelt

Verfassung

Unten für diejenigen, die das serverlose Framework kennen, für diejenigen, die Python irgendwie verstehen können Die Erklärung wird weggelassen. Bitte sehen Sie nur als Referenz.

functions/layers/serverless.yml　　#Konfigurationsdatei
functions/layers/package.json　　　#Paketbezogen
functions/layers/requirements.txt #Paketbezogen
functions/layers/python/util.py　　#Gemeinsame Funktion

functions/main/serverless.yml　　#Konfigurationsdatei
functions/main/handler.py        #Hauptgericht von Lambda

Es ist praktisch, Ebenen zu erstellen, wenn viele Pakete vorhanden sind. Referenz Aws Lambda Layer

Beschreibung jedes Moduls

functions/layers/serverless.yml

service: goole-test-layer
frameworkVersion: "2"

plugins:
  - serverless-python-requirements

custom:
  defaultStage: dev
  pythonRequirements:
    dockerizePip: true
    layer: true

provider:
  name: aws
  runtime: python3.8
  stage: ${opt:stage, self:custom.defaultStage}
  region: ap-northeast-1
  environment:
    TZ: Asia/Tokyo

package:
  exclude:
    - ./node_modules/** #Definieren Sie, wo sich das Paket befindet

layers:
  LayersCommon:
    path: "./"  #Wenn Sie es in einen Ordner namens Python legen, kann es als allgemeine Funktion von der Lambda-Seite aufgerufen werden.
    compatibleRuntimes:
      - python3.8

resources:
  Outputs:
    PythonRequirementsLambdaLayerExport:
      Value:
        Ref: PythonRequirementsLambdaLayer ##Wird in den Einstellungen auf der Funktionsseite verwendet
    LayersCommonLambdaLayerExport:
      Value:
        Ref: LayersCommonLambdaLayer ##Wird in den Einstellungen auf der Funktionsseite verwendet

functions/layers/package.json

{
  "name": "sample",
  "description": "",
  "version": "0.1.0",
  "dependencies": {},
  "devDependencies": {
    "serverless-python-requirements": "^5.1.0"
  }
}

functions/layers/requirements.txt

boto3
botocore
gspread
oauth2client

functions/main/serverless.yml

service: goole-test
frameworkVersion: "2"

custom:
  defaultStage: dev
  sampleS3BucketName:
    Fn::Join:
      - ""
      - - ${self:service}-
        - ${self:provider.stage}-
        - Ref: AWS::AccountId
  ##Ebeneneinstellungen[packege]
  requirements_service: goole-test-layer
  requirements_export: PythonRequirementsLambdaLayerExport
  requirements_layer: ${cf:${self:custom.requirements_service}-${self:provider.stage}.${self:custom.requirements_export}}
  ##Ebeneneinstellungen[common]
  layers_common_service: goole-test-layer
  layers_common_export: LayersCommonLambdaLayerExport
  layers_common: ${cf:${self:custom.layers_common_service}-${self:provider.stage}.${self:custom.layers_common_export}}

provider:
  name: aws
  runtime: python3.8
  stage: ${opt:stage, self:custom.defaultStage}
  region: ap-northeast-1
  logRetentionInDays: 30
  environment:
    KEYNAME : "/google/access_key" #Speicherort des erstellten Schlüssels
  iamRoleStatements:
    - Effect: "Allow"
      Action:
        - "s3:ListBucket"
        - "s3:GetObject"
        - "s3:PutObject"
      Resource:
        - Fn::Join: ["", ["arn:aws:s3:::", { "Ref": "S3Bucket" }]]
        - Fn::Join: ["", ["arn:aws:s3:::", { "Ref": "S3Bucket" }, "/*"]]
    - Effect: Allow
      Action:
        - secretsmanager:GetSecretValue
      Resource:
        - "*" #Die Berechtigungskontrolle ist durch Angabe des Arns des Secrets Managers möglich

functions:
  google_test:
    handler: handler.google_test
    memorySize: 512
    timeout: 900
    layers:
      - ${self:custom.requirements_layer}
      - ${self:custom.layers_common}
    events:
      - s3:                 #Legen Sie das S3-Erstellungsobjekt fest, das derzeit häufig verwendet wird
          bucket:
            Ref: S3Bucket
          event: s3:ObjectCreated:*
          existing: true
          rules:
            - suffix: .csv

resources:
  Resources:
    S3Bucket:                           #Erstellen Sie S3
      Type: AWS::S3::Bucket
      Properties:
        BucketName: ${self:custom.sampleS3BucketName}

functions/main/hander.py Ich trage es seitwärts und schreibe alles in ein Modul, aber bitte teilen Sie die Datei für jede Funktion ...

import json
import os
import boto3
from botocore.exceptions import ClientError
import base64
import gspread
from oauth2client.service_account import ServiceAccountCredentials


def get_secret():
    #Dies entspricht fast dem Beispielcode beim Erstellen von Secrets Manager
    try:
        secret = None
        decoded_binary_secret = None

        secret_name = os.environ['KEYNAME']
        region_name = "ap-northeast-1"

        # Create a Secrets Manager client
        session = boto3.session.Session()
        client = session.client(
            service_name='secretsmanager',
            region_name=region_name
        )

        get_secret_value_response = client.get_secret_value(
            SecretId=secret_name
        )

    except ClientError as e:
        if e.response['Error']['Code'] == 'DecryptionFailureException':
            raise e
        elif e.response['Error']['Code'] == 'InternalServiceErrorException':
            raise e
        elif e.response['Error']['Code'] == 'InvalidParameterException':
            raise e
        elif e.response['Error']['Code'] == 'InvalidRequestException':
            raise e
        elif e.response['Error']['Code'] == 'ResourceNotFoundException':
            raise e
    else:
        if 'SecretString' in get_secret_value_response:
            secret = get_secret_value_response['SecretString']
        else:
            decoded_binary_secret = base64.b64decode(
                get_secret_value_response['SecretBinary'])

    # Your code goes here.
    return decoded_binary_secret.decode()


def connect_gspread(jsonf, key):
    scope = ['https://spreadsheets.google.com/feeds',
             'https://www.googleapis.com/auth/drive']
    credentials = ServiceAccountCredentials.from_json_keyfile_name(
        jsonf, scope)
    gc = gspread.authorize(credentials)
    SPREADSHEET_KEY = key
    worksheet = gc.open_by_key(SPREADSHEET_KEY).sheet1
    return worksheet


def google_test(event, context):

    #Weil es als Datei an die API übergeben wird/Lassen Sie uns zu tmp ausgeben.
    jsonf = "/tmp/google-access.json"

    with open(jsonf, mode='w') as f:
        f.write(get_secret())

    spread_sheet_key = '1o3xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx'
    ws = connect_gspread(jsonf, spread_sheet_key)

    #Setzen Sie hoge1 in Zelle A1 ein
    ws.update_cell(1, 1, "hoge1")

    body = {
        "message": "{} !".format("finished ."),
        "input": event
    }

    response = {
        "statusCode": 200,
        "body": json.dumps(body)
    }

    return response

Bereitstellen

##Bereitstellung aus Ebenen
cd functions/layers
npm install
pip install -r requirements.txt
sls deploy

##Stellen Sie die Hauptfunktion bereit
cd functions/main
sls deploy

Lauf! !! !!

Hoge1 hat die A1-Zelle sicher betreten!

So konnte ich die Tabelle von AWS Lambda aktualisieren. Nun, soll ich es in GAS schreiben? Es gibt auch einen Tsukkomi, aber wenn Sie so etwas machen wollen Wir würden uns freuen, wenn Sie sich darauf beziehen könnten.

Hab ein gutes AWS-Leben!