J'ai construit l'environnement de développement d'AWS Chalice avec docker et j'ai essayé de déployer une application sans serveur à très haute vitesse

Chalice et Lambda sont nouveaux pour moi, Je suis enthousiasmé par ma première application sans serveur, je vais donc l'écrire

Code source naokit-dev / python3_chalice_on_docker

Calice?

Framework Python fourni par AWS Déployez facilement des applications sans serveur avec Lambda Documentation — AWS Chalice

environnement

macOS Catalina
VS Code
Docker Desktop

docker --version
Docker version 19.03.13, build 4484c46d9d
docker-compose --version
docker-compose version 1.27.4, build 40524192

De plus, ** la clé d'accès AWS est requise **

Mouvement préparatoire

Vérifiez l'image utilisée par Docker Hub python - Docker Hub

AWS Chalice peut utiliser tous les pythons pris en charge par Lambda, mais la série 3 est recommandée

AWS Chalice supports all versions of python supported by AWS Lambda, which includes python2.7, python3.6, python3.7, python3.8. We recommend you use a version of Python 3. Quickstart — AWS Chalice

Ici, je vais essayer d'utiliser 3.8-alpine

Créer un nouvel espace de travail avec VS Code Je l'ai fait "python3_chalice_on_docker"

(Je n'ai pas besoin des étapes suivantes, mais je l'ai essayé comme configuration minimale pour laquelle python fonctionne)

Tirez l'image Docker Hub et lancez le conteneur

--- il s'attache à l'entrée standard ---- rm Supprimer le conteneur à la sortie du conteneur --- v <host_path>: <container_path> Monter host_path en tant que volume

docker run -it --rm -v $PWD:/python python:3.8-alpine /bin/sh

(Si vous essayez de monter avec un chemin relatif comme -v.: / Python, vous obtiendrez une erreur, mais il semble que vous puissiez utiliser la variable d'environnement $ PWD, et il n'y a pas de problème avec -v $ PWD: / python | Volume relatif Je veux exécuter docker même si je spécifie le chemin! --Qiita)

# python --version
Python 3.8.6

Créer un Dockerfile

Vous travaillerez dans l'espace de travail que vous avez créé précédemment

Créer Dockerfile Installez le calice avec pip install calice

touch Dockerfile

FROM python:3.8-alpine

WORKDIR /app

RUN pip install chalice

CMD [ "/bin/sh"]

Ensuite, créez docker-compose.yml En plus du mappage de port et de la création de volume, les variables d'environnement décrites dans .env peuvent être gérées dans le conteneur.

touch docker-compose.yml

version: "3.8"
services:
  app:
    build: .
    ports:
      - "80:8000"
    volumes:
      - .:/app
    command: chalice local --host=0.0.0.0 --port=8000
    tty: true
    stdin_open: true
    working_dir: "${APP_PATH}"
    environment:
      - AWS_ACCESS_KEY_ID=${AWS_ACCESS_KEY_ID}
      - AWS_SECRET_ACCESS_KEY=${AWS_SECRET_ACCESS_KEY}
      - AWS_DEFAULT_REGION=${AWS_DEFAULT_REGION}

Créer .env Définissez ici les variables d'environnement ʻAPP_NAME` est maintenant vide D'autres peuvent être laissés tels quels pour le moment, mais vous écrirez les informations d'identification nécessaires pour déployer sur AWS.

touch .env

APP_NAME=
APP_PATH=/app/${APP_NAME}
AWS_ACCESS_KEY_ID=[YOUR_ACCESS_KEY_ID]
AWS_SECRET_ACCESS_KEY=[YOUR_SECRET_ACCESS_KEY]
AWS_DEFAULT_REGION=ap-northeast-1

Si les informations d'identification AWS sont stockées sur l'appareil Vous pouvez vérifier ci-dessous

cat ~/.aws/credentials

Créer un projet de calice

Créez un nouveau projet avec calice new-project <project_name>

docker-compose run app chalice new-project test_chalice

Il a la configuration suivante

.
├── .env
├── Dockerfile
├── docker-compose.yml
└── test_chalice
    ├── .chalice
    │   └── config.json
    ├── .gitignore
    ├── app.py
    └── requirements.txt

Définir les variables d'environnement

Modifier .env Entrez le nom du projet dans APP_NAME, ainsi que AWS_ACCESS_KEY_ID et AWS_SECRET_ACCESS_KEY ici. La région est définie sur «ap-nord-est-1», mais veuillez la modifier en conséquence.

APP_NAME=test_chalice
APP_PATH=/app/${APP_NAME}
AWS_ACCESS_KEY_ID=xxxxxxxxxxxxxxxxxx
AWS_SECRET_ACCESS_KEY=xxxxxxxxxxxxxxxxxx
AWS_DEFAULT_REGION=ap-northeast-1

Configurer un serveur local

Démarrer le serveur local

docker-compose up

J'ai remplacé la commande dans docker-compose.yml comme command: calice local --host = 0.0.0.0 --port = 8000, donc calice local est exécuté lorsque docker-compose up

ports: -" 80: 8000 " mappe le port 80 du côté hôte sur le port 8000 dans le conteneur, donc lorsque vous accédez à localhost depuis l'hôte, il sera transféré vers le serveur local de calice.

curl localhost
{"hello":"world"}%

"bonjour le monde" est retourné

Jetons un œil à test_chalice / app.py Supprimer les commentaires des parties commentées suivantes

# @app.route('/hello/{name}')
# def hello_name(name):
#    # '/hello/james' -> {"hello": "james"}
#    return {'hello': name}

Quand j'essaye d'accéder à / hello / calice

curl localhost/hello/chalice
{"hello":"chalice"}%

"bonjour calice" est retourné Vous pouvez voir le comportement RESTful

Arrêter le serveur local

docker-compose down

Essayez de déployer

Déployé en tant que fonction AWS Lambda avec Chalice deploy

docker-compose run app chalice deploy

Creating deployment package.
Creating IAM role: test_chalice-dev
Creating lambda function: test_chalice-dev
Creating Rest API
Resources deployed:
  - Lambda ARN: arn:aws:lambda:ap-northeast-1:xxxxxxxxxxxx:function:test_chalice-dev
  - Rest API URL: https://xxxxxxxxxx.execute-api.ap-northeast-1.amazonaws.com/api/

Essayez d'accéder à l'URL de l'API Rest

curl https://xxxxxxxxxx.execute-api.ap-northeast-1.amazonaws.com/api/
{"hello":"world"}%

curl https://xxxxxxxxxx.execute-api.ap-northeast-1.amazonaws.com/api/hello/lambda
{"hello":"lambda"}%

calice analyse le code Il semble qu'elle sera déployée en tant que fonction Lambda avec le rôle IAM requis.

Ensuite, j'aimerais essayer une application un peu pratique.

Ref. Documentation — AWS Chalice