Der Dezember war früh und wir erreichten die mittlere Stufe. Persönlich fühle ich mich sehr glücklich, weil dieser Tag mein Geburtstag ist. Ich habe diesen Artikel mit diesem Gefühl geschrieben. Ich habe kürzlich Serverless Framework und AWS berührt, also habe ich es selbst zusammengefasst. Die Dienste, die ich verwendet habe, sind Lambda und S3, SQS und API Gateway, also habe ich darüber geschrieben.
Der diesmal verwendete Code ist [hier] zu finden (https://github.com/masaemon/aws-serverless).
Außerdem habe ich bei der Erstellung dieses Artikels auf die folgenden Artikel verwiesen. Gründlich serverlos ①: Einführung in Serverless Framework Die Geschichte der Erstellung eines supereinfachen Abstimmungssystems mit Serverless Framework und S3 [Ich habe versucht, Lambda mit Python 3.6 mit Serverless Framework zu verwenden] (https://dev.classmethod.jp/cloud/aws/serverless-framework-with-python-3-6/) Zusammenfassung der Verwendung von Serverless Framework
Benötigt Node.js und Python-Umgebung. Sie benötigen außerdem ein AWS-Konto. Node.js ist erforderlich, um Serverless Framework zu verwenden, und Python ist erforderlich, um AWS CLI zu verwenden.
Mit npm installieren.
$ npm install -g serverless
＄ sls -v
Framework Core: 1.54.0
Plugin: 3.1.2
SDK: 2.1.2
Components Core: 1.1.1
Components CLI: 1.4.0
Wenn dies angezeigt wird, ist die Installation abgeschlossen.
Sie müssen ein IAM erstellen, um AWS mit Serverless Framework verwenden zu können.
Sie können es erstellen, indem Sie im IAM-Dashboard auf Benutzer aus Benutzer erstellen klicken. Grundsätzlich müssen Sie nur den programmatischen Zugriff überprüfen und ihm die Berechtigungen erteilen, die Sie diesmal zum Erstellen benötigen. Beachten Sie auch, dass der AWS-Anmeldeinformationsschlüssel nur hier erhältlich ist.
Sie müssen die AWS CLI installieren, um die Einstellungen für die AWS-Anmeldeinformationen zu konfigurieren. Sie können es mit dem folgenden Befehl installieren.
$ pip install aws-sdk
$ aws --version
aws-cli/1.16.276 Python/3.7.3 Darwin/18.7.0 botocore/1.13.12
Wenn dies angezeigt wird, ist die Installation abgeschlossen. Stellen Sie den AWS-Berechtigungsnachweis wie folgt ein.
$ aws configure
AWS Access Key ID [None]:IAM-Zugriffsschlüssel-ID erstellt
AWS Secret Access Key [None]:Erstellt einen geheimen IAM-Zugriffsschlüssel
Default region name [None]: ap-northeast-1
Default output format [None]: ENTER
Zitat: Gründlich ohne Server ①: Einführung in Serverless Framework
Jetzt können Sie das Serverless Framework verwenden.
Lassen Sie uns zunächst ein serverloses Projekt erstellen. Sie können es erstellen, indem Sie den folgenden Befehl eingeben.
$ sls create -t aws-python3 -p Hogehoge-Projekt
Wenn Folgendes angezeigt wird, ist dies erfolgreich.
Serverless: Generating boilerplate...
Serverless: Generating boilerplate in "/..."
_______ __
| _ .-----.----.--.--.-----.----| .-----.-----.-----.
| |___| -__| _| | | -__| _| | -__|__ --|__ --|
|____ |_____|__| \___/|_____|__| |__|_____|_____|_____|
| | | The Serverless Application Framework
| | serverless.com, v1.54.0
-------'
Serverless: Successfully generated boilerplate for template: "aws-python3"
Als nächstes ändern Sie `` `handler.py``` im Projektnamenverzeichnis wie folgt.
handler.py
import json
def hello(event, context):
body = {
"message": "Hello, world",
}
response = {
"statusCode": 200,
"body": json.dumps(body)
}
return response
Stellen Sie außerdem die Bereitstellungszielregion auf Tokio ein.
serverless.yml
service:Hogehoge
provider:
name: aws
runtime: python3.7
region: ap-northeast-1 #In der Region Tokio bereitstellen
functions:
hello:
handler: handler.hello
Dann bereitstellen.
$ sls deploy
Ich werde das machen.
＄ sls invoke -f hello
Wenn Folgendes angezeigt wird, ist dies erfolgreich.
{
"statusCode": 200,
"body": "{\"message\": \"Hello, world\"}"
}
Außerdem ist im AWS Lambda-Dashboard eine Funktion bereitgestellt, sodass Sie versuchen können, sie von dort aus auszuführen.
Lassen Sie uns zunächst die zuvor mit API Gateway bereitgestellte Hallo-Funktion ausführen. Ändern Sie `` `serverless.yml``` wie folgt.
serverless.yml
service:Hogehoge
provider:
...
functions:
hello:
handler: handler.hello
#Von hier aus hinzufügen
events:
- http:
path: hello
method: get
cors: true
Zitat: https://serverless.com/framework/docs/providers/aws/events/apigateway/
Wenn Sie danach `sls deploy``` ausführen, erhalten Sie` Endpunkte``` wie unten gezeigt.
Service Information
...
endpoints:
GET - https://hogehoge.amazonaws.com/dev/hello
functions:
hello: hogehoge-dev-hello
layers:
None
Wenn Sie diese API mit einem Curl-Befehl usw. drücken, wird Hello World angezeigt.
Erstellen Sie eine neue `` `sthreeput.py``` und schreiben Sie wie folgt. Hier erstellen wir eine Funktion, die eine Textdatei mit 10 Zufallszahlen bis zu 100 mit dem Namen von Datum und Uhrzeit speichert.
sthreeput.py
import boto3 #AWS SDK für Python
import datetime
import random
s3 = boto3.resource('s3')
bucketName = "hogehogebucket" #Der Name des S3-Buckets, für den Sie sich entschieden haben
def index(event, context):
dt = datetime.datetime.now()
text = ""
for i in range(10):
num = str(random.randint(0, 100))
text += num + " "
key = "{0:%Y-%m-%d-%H-%M-%S}.txt".format(dt) #Werden Sie zum zu speichernden Dateinamen
obj = s3.Object(bucketName, key)
obj.put(Body=text.encode())
return {
"statusCode": 200,
"body": text
}
Erstellen Sie einen S3-Bucket zum Speichern der Dateien. Außerdem wird eine Funktion zum Hinzufügen von Dateien zu S3 beschrieben. Bitte beachten Sie, dass der Bucket-Name von S3 nicht verwendet werden kann, wenn er bereits vorhanden ist (auch wenn er nicht Ihr eigener ist).
serverless.yml
functions:
hello:
....
#Funktionsname
sthree-put:
handler: sthreeput.index #sthreeput.Ruft die Indexfunktion von py auf
resources:
Resources:
SthreeBucket: #Erstellen Sie einen Bucket für S3
Type: AWS::S3::Bucket
Properties:
BucketName : "hogehogebucket" #Name des S3-Buckets (kann noch nicht benannt werden)
Lassen Sie uns nun `` `sls deploy``` ausführen und die Funktion ausführen. Wenn alles gut geht, enthält der von Ihnen erstellte Bucket die Datei.
Erstellen Sie eine neue `` `sthreereceive.py``` wie folgt.
sthreereceive.py
import boto3
s3 = boto3.client('s3')
def index(event, context):
bucket = event["Records"][0]["s3"]["bucket"]["name"] #Eimername
key = event["Records"][0]["s3"]["object"]["key"] #Der Name der gespeicherten Datei
response = s3.get_object(Bucket=bucket, Key=key) #Holen Sie sich die Objekte in den Eimer
body = response['Body'].read().decode("utf-8") #Holen Sie sich die Informationen in die Datei und utf-Auf 8 dekodieren
print(body)
return body
Wenn die Lambda-Funktion durch Verknüpfen mit S3 gestartet wird, wird der folgende JSON an das erste Argumentereignis übergeben.
{
"Records": [
{
"eventVersion": "2.0",
"eventSource": "aws:s3",
"awsRegion": "ap-northeast-1",
"eventTime": "1970-01-01T00:00:00.000Z",
"eventName": "ObjectCreated:Put",
"userIdentity": {
"principalId": "EXAMPLE"
},
"requestParameters": {
"sourceIPAddress": "127.0.0.1"
},
"responseElements": {
"x-amz-request-id": "EXAMPLE123456789",
"x-amz-id-2": "EXAMPLE123/5678abcdefghijklambdaisawesome/mnopqrstuvwxyzABCDEFGH"
},
"s3": {
"s3SchemaVersion": "1.0",
"configurationId": "testConfigRule",
"bucket": {
"name": "example-bucket",
"ownerIdentity": {
"principalId": "EXAMPLE"
},
"arn": "arn:aws:s3:::example-bucket"
},
"object": {
"key": "test/key",
"size": 1024,
"eTag": "0123456789abcdef0123456789abcdef",
"sequencer": "0A1B2C3D4E5F678901"
}
}
}
]
}
Aus diesen Informationen erhalten wir den Namen des S3-Buckets und den Schlüssel, der der Dateiname ist.
Stellen Sie die Funktion und das Ereignis von S3 ein.
serverless.yml
...
functions:
sthree-put:
handler: sthreeput.index #sthreeput.Ruft die Indexfunktion von py auf
sthree-receive:
handler: sthreereceive.index
events:
- s3:
bucket: "sthreebucket-hogehoge" #Eimername
event: s3:ObjectCreated:* #Starten Sie mit S3
existing: true #Da ich einen Bucket für S3 erstelle, werde ich diesen anhängen
Ohne das letzte `existierende: ture``` wird ein Bucket erstellt und Sie können ihn nicht bereitstellen, wenn Sie bereits einen Bucket mit demselben Namen haben. Wir haben diese Option festgelegt, weil wir den Bucket früher erstellt haben. Sie können ohne die letzte Option bereitstellen, indem Sie den Ressourcenteil von serverless.yml löschen und `sls remove``` ausführen, um es sauber zu machen.
Wenn Sie nun `` `sls deploy``` ausführen und die sthreeput-Funktion starten, wird die Datei im Bucket gespeichert und Sie können anhand der Überwachung des Lambda-Dashboards erkennen, dass die sthreereceive-Funktion gestartet wurde.
Auch dieses Mal habe ich die Datei überprüft, indem ich die Tatsache verwendet habe, dass sie in S3 als Auslöser gespeichert wurde. Sie können die Datei jedoch auch überprüfen, indem Sie den Namen des Buckets und den Schlüssel der Datei angeben, die Sie überprüfen möchten.
Beschreiben Sie `` `sendmessage.py``` neu wie folgt.
sendmessage.py
import boto3
import random
import json
sqs = boto3.resource('sqs')
queueName = "hogehoge-queue"
def index(event, context):
queue = sqs.get_queue_by_name(QueueName=queueName) #Warteschlange holen
message = "" #Nachricht zum Senden
for i in range(10):
num = str(random.randint(0, 100))
message += num + " "
print(message)
queue.send_message(MessageBody=json.dumps({ "message": message })) #Nachricht senden
return message
Erstellen Sie eine Warteschlange zum Senden von Nachrichten. Im Gegensatz zum S3-Bucket kann der Name der SQS-Warteschlange mit dem eines anderen Kontos identisch sein.
serverless.yml
provider:
...
iamRoleStatements:
- Effect: "Allow"
Action:
- "s3:PutObject"
- "s3:GetObject"
- "s3:ListBucket"
- "sqs:CreateQueue"
- "sqs:DeleteQueue"
- "sqs:SendMessage"
- "sqs:GetQueueUrl"
Resource: "*"
...
functions:
sthree-put:
...
sendmessage:
handler: sendmessage.index
resources:
Resources:
SthreeBucket:
...
hogehogeQueue:
Type: AWS::SQS::Queue #Erstellung der SQS-Warteschlange
Properties:
QueueName: "hogehoge-queue"
Führen Sie nun eine `` `sls deploy``` durch und starten Sie die Sendmessage-Funktion. Die Nachricht sollte der von Ihnen erstellten Warteschlange hinzugefügt werden.
Als nächstes erhalten wir die Nachricht, die Sie zuvor gesendet haben. Erstellen Sie `` `Receivemessage.py``` und schreiben Sie wie folgt.
receivemessage.py
import json
def index(event, context):
body = json.loads(event["Records"][0]["body"])
message = body["message"]
print(message)
return message
Wenn die Lambda-Funktion durch Einbinden von SQS gestartet wird, wird der folgende JSON an das erste Argumentereignis übergeben.
{
"Records": [
{
"messageId": "19dd0b57-b21e-4ac1-bd88-01bbb068cb78",
"receiptHandle": "MessageReceiptHandle",
"body": "Hello from SQS!",
"attributes": {
"ApproximateReceiveCount": "1",
"SentTimestamp": "1523232000000",
"SenderId": "123456789012",
"ApproximateFirstReceiveTimestamp": "1523232000001"
},
"messageAttributes": {},
"md5OfBody": "7b270e59b47ff90a553787216d55d91d",
"eventSource": "aws:sqs",
"eventSourceARN": "arn:aws:sqs:ap-northeast-1:123456789012:MyQueue",
"awsRegion": "ap-northeast-1"
}
]
}
Sie können die gesendete Nachricht erhalten, indem Sie den Körper von hier abrufen.
serverlss.yml
...
functions:
receivemessage:
handler: receivemessage.index
events:
- sqs:
# arn:aws:sqs:region:accountid:hogehoge-Werde wie eine Warteschlange
arn:
Fn::Join:
- ':'
- - arn
- aws
- sqs
- Ref: AWS::Region
- Ref: AWS::AccountId
- "hogehoge-queue"
Wenn Sie nun `` `sls deploy``` ausführen und die Sendmessage-Funktion starten, wird die Receivemessage-Funktion gestartet. Beachten Sie, dass die Empfangsnachrichtenfunktion immer aufgerufen wird, wenn sie einen Fehler verursacht. In diesem Fall können Sie es stoppen, indem Sie die Nachricht in der Warteschlange löschen.
Löschen Sie es, wenn Sie es nicht brauchen. Der folgende Befehl bereinigt es.
sls remove
Der Bucket verschwindet nicht gut. In diesem Fall möchten Sie möglicherweise den Bucket leeren oder den Stapel direkt löschen.
Ich dachte, ich sollte versuchen, AWS zu berühren, da es verschiedene andere Dienste gibt.
Recommended Posts