def create_app() -> FlaskLambda:
'''Create an app by initializing components'''
app = FlaskLambda(__name__)
_initialize_blueprints(app)
# Do it!
return app
def init_flask_for_env():
"""
Loads flask for lambda or local debug.
"""
from os import environ
if 'LOCAL_DEBUG' in environ:
from flask import Flask
return Flask(__name__)
else:
from flask_lambda import FlaskLambda
return FlaskLambda(__name__)
def create_app():
'''
Create an app by initializing components.
'''
application = FlaskLambda(__name__)
_initialize_errorhandlers(application)
_initialize_blueprints(application)
# Do it!
return application
def create_lambda_app() -> FlaskLambda:
"""Create Flask Lambda app for deploying on AWS.
Returns:
app (Flask): flask application
"""
database_name = os.environ.get("DB_NAME")
cluster_arn = os.environ.get("DB_CLUSTER_ARN")
secret_arn = os.environ.get("DB_SECRET_ARN")
secret_key = os.environ.get("SECRET_KEY", DEFAULT_SECRET_KEY)
app = FlaskLambda(__name__)
app.config.from_mapping(
DEBUG=False,
SECRET_KEY=secret_key,
SQLALCHEMY_DATABASE_URI=f"mysql+auroradataapi://:@/{database_name}",
SQLALCHEMY_ENGINE_OPTIONS={
"connect_args":
dict(aurora_cluster_arn=cluster_arn, secret_arn=secret_arn)
},
SQLALCHEMY_TRACK_MODIFICATIONS=False,
)
# Add a test route
@http.route("/test-deployment/")
def test():
return Response(
json.dumps({"message": "Serverless deployment successful"}),
status=200,
mimetype="application/json",
)
app.register_blueprint(http, url_prefix=r"/")
# Setup database
global db
db.init_app(app)
s = app.app_context().push() # Push the app into context
try:
db.Model.metadata.create_all(
db.engine, checkfirst=False) # Create database tables
seed_db() # Seed the database
except Exception as e:
print("Error", e)
db.session.commit()
return app
import os
from flask_lambda import FlaskLambda
from flask import request, jsonify
from flask_sqlalchemy import SQLAlchemy
from flask_marshmallow import Marshmallow
from marshmallow import ValidationError
from serializers import MovieSchema
from utils import initialize_movie
app = FlaskLambda(__name__)
app.config['SQLALCHEMY_DATABASE_URI'] = os.environ.get('DATABASE_URL')
app.config['SQLALCHEMY_TRACK_MODIFICATIONS'] = False
app.config['JSON_SORT_KEYS'] = False
db = SQLAlchemy(app)
ma = Marshmallow(app)
class Movie(db.Model):
__tablename__ = "movies"
id = db.Column(db.Integer, primary_key=True)
title = db.Column(db.String(300))
year = db.Column(db.String(50))
age = db.Column(db.String(10))
imbd = db.Column(db.String(10))
rotten_tomatoes = db.Column(db.String(10))
netflix = db.Column(db.String(10))
hulu = db.Column(db.String(10))
def create_lambda_app(node_id: str) -> FlaskLambda:
"""Create flask application for hosting on AWS Lambda.
Args:
node_id: ID used to identify this node.
Returns:
app : FlaskLambda App instance.
"""
# Register dialects to talk to AWS RDS via Data API
import sqlalchemy_aurora_data_api
sqlalchemy_aurora_data_api.register_dialects()
database_name = os.environ.get("DB_NAME")
cluster_arn = os.environ.get("DB_CLUSTER_ARN")
secret_arn = os.environ.get("DB_SECRET_ARN")
app = FlaskLambda(__name__)
app.config.from_mapping(
DEBUG=False,
SQLALCHEMY_DATABASE_URI=f"mysql+auroradataapi://:@/{database_name}",
SQLALCHEMY_ENGINE_OPTIONS={
"connect_args":
dict(aurora_cluster_arn=cluster_arn, secret_arn=secret_arn)
},
SQLALCHEMY_TRACK_MODIFICATIONS=False,
)
# Register app blueprints
from .main import (
auth,
data_centric_routes,
hook,
local_worker,
main_routes,
model_centric_routes,
ws,
)
# Add a test route
@main_routes.route("/test-deployment/")
def test():
return Response(
json.dumps({"message": "Serverless deployment successful."}),
status=200,
mimetype="application/json",
)
# set_node_id(id)
local_worker.id = node_id
hook.local_worker._known_workers[node_id] = local_worker
local_worker.add_worker(hook.local_worker)
# Register app blueprints
app.register_blueprint(main_routes, url_prefix=r"/")
app.register_blueprint(model_centric_routes, url_prefix=r"/model-centric")
app.register_blueprint(data_centric_routes, url_prefix=r"/data-centric")
# Setup database
global db
db.init_app(app)
s = app.app_context().push() # Push the app into context
try:
db.Model.metadata.create_all(
db.engine, checkfirst=False) # Create database tables
seed_db() # Seed the database
except Exception as e:
print("Error", e)
db.session.commit()
# Set Authentication configs
app = auth.set_auth_configs(app)
CORS(app)
# Threads
executor.init_app(app)
app.config["EXECUTOR_PROPAGATE_EXCEPTIONS"] = True
app.config["EXECUTOR_TYPE"] = "thread"
return app
import json
from flask_lambda import FlaskLambda
import boto3
import os
from flask import request, redirect
from uuid import uuid4
from datetime import datetime
handler = FlaskLambda(__name__)
s3 = boto3.client("s3")
bucketName = os.environ["BUCKET_NAME"]
dynamoDB = boto3.resource("dynamodb")
tableName = dynamoDB.Table(os.environ["DYNAMO_TABLE_NAME"])
@handler.route('/')
def index():
response = {"message": " Bienvenue sur le site de partage"}
return (json.dumps(response), 200, {'Content-Type': 'application/json'})
@handler.route('/objects', methods=['GET'])
def listobject():
response = s3.list_objects_v2(Bucket=bucketName)["Contents"]
return (json.dumps(response, indent=4, sort_keys=True, default=str), 200, {
'Content-Type': 'application/json'
})
@handler.route("/shares", methods=["GET", "POST", "DELETE"])
def list_or_put_object():
from . import text
from flask_lambda import FlaskLambda
from flask import request, jsonify
kwargs = {}
app_path = os.path.dirname(__file__)
kwargs.update({
'static_url_path':
'',
'static_folder':
os.path.join(os.path.abspath(app_path), 'client')
})
app = FlaskLambda(__name__, **kwargs)
@app.route('/')
def index():
return app.send_static_file('index.html')
@app.route('/render', methods=['POST'])
def render_template():
data = request.get_json()
client = docker.from_env()
repository, tag = docker.utils.parse_repository_tag(
os.getenv('DOCKER_IMAGE', 'sivel/ansible-template-ui'))
def create_app_lambda():
app = FlaskLambda(__name__)
return configure_app(app)