Je voulais utiliser la feuille de calcul Google avec AWS lambda, alors je l'ai essayé [Partie 2]
Aperçu
Ceci est une continuation de l'article précédent. La dernière fois que j'ai créé la moitié inférieure, cette fois je vais créer la moitié supérieure
environnement de cadre sans serveur
Environnement d'exploitation
npm (6.14.8): Si ce n'est pas vieux ... sans serveur (2.8.0): s'il s'agit de la série 2.x.x python (3.8.2): s'il s'agit d'une série 3.8
Constitution
Ci-dessous, pour ceux qui connaissent le framework sans serveur, pour ceux qui peuvent comprendre python d'une manière ou d'une autre L'explication est omise. S'il vous plaît voir pour référence seulement.
functions/layers/serverless.yml #Fichier de configuration
functions/layers/package.json #Lié au package
functions/layers/requirements.txt #Lié au package
functions/layers/python/util.py #Fonction commune
functions/main/serverless.yml #Fichier de configuration
functions/main/handler.py #Main de lambda
Il est pratique de créer des couches lorsqu'il existe de nombreux packages. Référence Aws Lambda Layer
Description de chaque module
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/** #Définir où se trouve le package
layers:
LayersCommon:
path: "./" #Si vous le placez dans un dossier appelé python, il peut être appelé du côté lambda en tant que fonction commune.
compatibleRuntimes:
- python3.8
resources:
Outputs:
PythonRequirementsLambdaLayerExport:
Value:
Ref: PythonRequirementsLambdaLayer ##Utilisé dans les réglages côté fonction
LayersCommonLambdaLayerExport:
Value:
Ref: LayersCommonLambdaLayer ##Utilisé dans les réglages côté fonction
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
##paramètres de calque[packege]
requirements_service: goole-test-layer
requirements_export: PythonRequirementsLambdaLayerExport
requirements_layer: ${cf:${self:custom.requirements_service}-${self:provider.stage}.${self:custom.requirements_export}}
##paramètres de calque[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" #Emplacement de stockage de la clé créée
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:
- "*" #Le contrôle des autorisations est possible en spécifiant arn du gestionnaire de secrets
functions:
google_test:
handler: handler.google_test
memorySize: 512
timeout: 900
layers:
- ${self:custom.requirements_layer}
- ${self:custom.layers_common}
events:
- s3: #Définissez l'objet de création S3 qui est souvent utilisé pour le moment
bucket:
Ref: S3Bucket
event: s3:ObjectCreated:*
existing: true
rules:
- suffix: .csv
resources:
Resources:
S3Bucket: #Créer S3
Type: AWS::S3::Bucket
Properties:
BucketName: ${self:custom.sampleS3BucketName}
functions/main/hander.py Je le porte sur le côté et je l'écris dans un seul module, mais veuillez diviser le fichier pour chaque fonction ...
import json
import os
import boto3
from botocore.exceptions import ClientError
import base64
import gspread
from oauth2client.service_account import ServiceAccountCredentials
def get_secret():
#C'est presque le même que l'exemple de code lors de la création de 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):
#Parce qu'il est transmis à l'API sous forme de fichier/Sortons en tmp.
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)
#Mettez hoge1 dans la cellule A1
ws.update_cell(1, 1, "hoge1")
body = {
"message": "{} !".format("finished ."),
"input": event
}
response = {
"statusCode": 200,
"body": json.dumps(body)
}
return response
Déployer
##Déployer à partir des couches
cd functions/layers
npm install
pip install -r requirements.txt
sls deploy
##Déployer la fonction principale
cd functions/main
sls deploy
Courir! !! !!
Hoge1 est entré en toute sécurité dans la cellule A1!
J'ai donc pu mettre à jour la feuille de calcul à partir d'AWS lambda. Eh bien, dois-je l'écrire en GAS? Il y a aussi un tsukkomi, mais si vous voulez faire quelque chose comme ça Nous vous serions reconnaissants si vous pouviez vous y référer.
Bonne vie AWS!
Recommended Posts