Serverlose Anwendungen mit AWS Fargate

Dieser Blog zeigt, wie Sie serverlose Anwendungen erstellen, die kontinuierlich laufen. Wir nennen diese Art von Anwendung
Serverless Continuous Running Application oder (SCRA). Bei dieser Art von Anwendung gibt es fast keine Begrenzung der Rechenleistung, des
Speichers oder der Größe des Code-Archivs. In diesem Blog werden wir einen einfachen Webservice mit Python und Flask erstellen.
Der Webservice wird als SCRA ausgeführt und auf Amazon Elastic Container Service (ECS)
bereitgestellt und auf Amazon Fargate ausgeführt.

Kontinuierlich vs. Ereignisgesteuert

Es gibt Unterschiede zwischen Serverless Functions (SF) und SCRA. SF wie AWS Lambda sind ereignisgesteuert,
werden bei Bedarf ausgeführt und haben Beschränkungen hinsichtlich der Codegröße, der Programmiersprache und der Ausführungszeit. SCRA haben
diese Beschränkungen nicht. SCRA werden kontinuierlich ausgeführt, haben keine Beschränkungen hinsichtlich der Codegröße und der Programmiersprache, die verwendet werden können.
Was die beiden Modelle gemeinsam haben, ist, dass Sie nur für das bezahlen, was Sie nutzen, keine Server verwalten und dass der Service
automatisch skaliert.

ECS und Fargate

SCRA werden mit Hilfe der Docker-Technologie verpackt und ausgeführt. Für die Ausführung, Skalierung und Verwaltung der SCRA
ist ein Orchestrator erforderlich, der entscheidet, wo die Anwendung im Rechenzentrum ausgeführt wird. AWS bietet einen kostenlosen und serverlosen
Orchestrator namens Amazon Elastic Container Service (ECS). Im April 2018 wurde AWS Fargate eingeführt,
eine Serverless Compute Engine für Container-Workloads auf AWS. Bis zur Veröffentlichung von Fargate war es notwendig,
bereitzustellen und eine Flotte virtueller Maschinen zu verwalten, um die Docker-Container auszuführen. Jetzt haben wir die Wahl, unsere eigene Flotte virtueller
Maschinen zu verwalten, auf denen die Container ausgeführt werden, und/oder die Container auf Fargate laufen zu lassen.

Bereitstellen einer serverlosen Anwendung

Für die Bereitstellung eines SCRA auf AWS müssen Sie die folgenden Ressourcen erstellen:

• Erstellung einer ECR-Docker-Registrierung,
• das Erstellen und Hochladen des Container-Images in die Registrierung,
• eine VPC erstellen,
• Erstellung eines ECS-Clusters,
• eine ECS-Aufgabendefinition erstellen, die definiert:
• awsvpc als Netzwerkmodus,
• FARGATE als Kompatibilität,
• Erstellung einer ECS-Dienstdefinition, die definiert:
• FARGATE als Starttyp,
• eine IAM-Rolle für die ECS-Aufgabe, die Zugriff auf ecr und logs hat,
• eine IAM-Rolle für den ECS-Cluster, die Zugriff auf ec2 hat, um Netzwerkschnittstellen zu erstellen,
• eine Sicherheitsgruppe, die den Zugriff auf den ECS-Dienst erlaubt

Der Webservice für Akteure

Flask macht es einfach, mit Python einen Webservice zu definieren. Der Code für den Webdienst 'actors' ist unten abgebildet.

from flask import Flask, jsonify
from flask_basicauth import BasicAuth

app = Flask(__name__)

app.config['BASIC_AUTH_USERNAME'] = 'user'
app.config['BASIC_AUTH_PASSWORD'] = 'password'
app.config['BASIC_AUTH_FORCE'] = True
basic_auth = BasicAuth(app)

actors = [
    {'id': 1, 'actor': 'William Shatner', 'role': 'James T'},
    {'id': 2, 'actor': 'Leonard Nimoy', 'role': 'Spock'},
    {'id': 3, 'actor': 'DeForest Kelley', 'role': 'Leonard McCoy'},
    {'id': 4, 'actor': 'James Doohan', 'role': 'Montgomery Scott'},
    {'id': 5, 'actor': 'George Takei', 'role': 'Hikaru Sulu'},
    {'id': 6, 'actor': 'Walter Koenig', 'role': 'Pavel Chekov'},
    {'id': 7, 'actor': 'Nichelle Nichols', 'role': 'Nyota Uhura'},
    {'id': 8, 'actor': 'Majel Barrett', 'role': 'Christine Chapel'}
]

@app.route('/actors', methods=['GET'])
def get_persons():
    return jsonify(actors), 200

@app.route('/actors/<int:id>', methods=['GET'])
def get_actor_by_id(id: int):
    found = None
    for actor in actors:
        if actor['id'] == id:
            found = actor
            break

    if found:
        return jsonify(found), 200
    else:
        return '', 404


app.run(debug=True, host="0.0.0.0", port=5000)

Beispiel

Das Beispielprojekt zeigt, wie Sie einen ECS-Cluster
erstellen, der einen Dienst auf Fargate als SCRA ausführt. Ich gehe davon aus, dass Sie einen Mac haben, auf dem python, pipenv und sceptre installiert sind. Um
einzusetzen, geben Sie in dem Beispiel ein. Um die IP-Adresse des laufenden Containers zu erhalten, geben Sie make get_ip ein.
Um das Beispiel zu entfernen, geben Sie make delete ein.
Der Webdienst kann mit einem beliebigen http-Client wie httpie aufgerufen werden:

$ http -a user:password http://<replace-with-ip-address>:5000/actors
HTTP/1.0 200 OK
Content-Length: 658
Content-Type: application/json
Date: Sun, 11 Nov 2018 10:28:41 GMT
Server: Werkzeug/0.14.1 Python/3.7.0
[
    { "actor": "William Shatner", "id": 1, "role": "James T" },
    { "actor": "Leonard Nimoy", "id": 2, "role": "Spock" }, 
    { "actor": "DeForest Kelley", "id": 3, "role": "Leonard McCoy" },
    { "actor": "James Doohan", "id": 4, "role": "Montgomery Scott" }, 
    { "actor": "George Takei", "id": 5, "role": "Hikaru Sulu" }, 
    { "actor": "Walter Koenig", "id": 6, "role": "Pavel Chekov" }, 
    { "actor": "Nichelle Nichols", "id": 7, "role": "Nyota Uhura" }, 
    { "actor": "Majel Barrett", "id": 8, "role": "Christine Chapel" }
]

Fazit

Serverless Continuous Running Applications (SCRA) sind Anwendungen, die kontinuierlich laufen. Diese Anwendungen können
mit Amazon ECS und Fargate bereitgestellt werden. SCRA benötigen eine Infrastruktur, um mit anderen Diensten wie
Webclients oder Datenbanken kommunizieren zu können. In diesem Blog haben wir uns mit der Erstellung eines einfachen 'actors' Webservice beschäftigt, der als serverlose
Anwendung auf Amazon Fargate läuft. Beim nächsten Mal werden wir den 'actors'-Webdienst auf Google App Engine bereitstellen.