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
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
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'))
import logging
from flask_lambda import FlaskLambda
from flask import request, jsonify, make_response, g
import jwt
import json
from jwt.algorithms import RSAAlgorithm
from jwt.exceptions import ExpiredSignatureError
from error_handler import error_handler, BadRequestException, SystemFailureException, SignatureExpiredException
logging.basicConfig(
level=logging.DEBUG,
format='%(asctime)s [%(levelname)s] (%(threadName)-10s) %(message)s')
lambda_handler = FlaskLambda(__name__)
logger = logging.getLogger(__name__)
def success_json_response(payload):
"""Turns payload into a JSON HTTP200 response"""
response = make_response(jsonify(payload), 200)
response.headers["Content-type"] = "application/json"
return response
def validate_jwt(token, key_set, aud):
# first we have to get the headers
headers = jwt.get_unverified_header(token)
public_key = ""
# then find the key
for key in key_set:
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
from aws_xray_sdk.core.context import Context
from aws_xray_sdk.ext.flask.middleware import XRayMiddleware
from flask import request, make_response
from flask_lambda import FlaskLambda
patch(('boto3',))
xray_recorder.configure(
service='x-ray-profiling-experiment',
dynamic_naming='*.execute-api.us-east-1.amazonaws.com/test*',
context=Context()
)
s3_client = boto3.resource('s3')
app = FlaskLambda(__name__)
XRayMiddleware(app, xray_recorder)
HOST = os.environ.get('HOST')
PORT = int(os.environ.get('PORT')) if 'PORT' in os.environ else None
bucket = 'logs-test-861229788715'
# health check endpoint
@app.route('/health')
def health():
return "OK"
# cache endpoint
@app.route('/cache/<key>', methods=['GET', 'PUT', 'DELETE'])
import os
import json
import requests
from flask_lambda import FlaskLambda
from flask import request
app = FlaskLambda(__name__)
# Set file upload requirements here: max file size, extension types(json and txt)
app.config["ALLOWED_FILE_EXTENSIONS"] = ["json"]
app.config['MAX_CONTENT_LENGTH'] = 64 * 1024 * 1024
@app.errorhandler(413)
def too_large(e):
return (json.dumps('File is too large'), 413, {
'Content-Type': 'application/json'
})
def allowed_file(filename):
print(filename, 'Uploaded Successfully')
if not "." in filename:
return False
ext = filename.rsplit(".", 1)[1]
if ext.lower() in app.config["ALLOWED_FILE_EXTENSIONS"]:
return True
else:
from flask import request, jsonify
import decimal
import os
import flask.json
import json
from flask_lambda import FlaskLambda
class MyJSONEncoder(flask.json.JSONEncoder):
def default(self, obj):
if isinstance(obj, decimal.Decimal):
return str(obj)
return super(MyJSONEncoder, self).default(obj)
app = FlaskLambda(__name__)
app.json_encoder = MyJSONEncoder
student_table_name = os.environ["TABLE_NAME"]
@app.after_request
def after_request(response):
response.headers.add('Access-Control-Allow-Origin',
'http://localhost:4200')
response.headers.add(
'Access-Control-Allow-Headers',
'Content-Type,X-Amz-Date,Authorization,X-Api-Key,X-Amz-Security-Token')
response.headers.add('Access-Control-Allow-Methods',
'GET,PUT,POST,DELETE,OPTIONS')
response.headers.add('Access-Control-Allow-Credentials', 'true')
response.headers.add('Content-Type', 'application/json')
import os
import decimal
from datetime import datetime, timedelta
import logging
from flask_lambda import FlaskLambda
from flask import jsonify, request
import psycopg2
import boto3
from flask_cors import CORS, cross_origin
logger = logging.getLogger()
logger.setLevel(logging.INFO)
app = FlaskLambda(__name__)
cors = CORS(app)
app.config["CORS_HEADERS"] = "Content-Type"
DB_CREDENTIALS = os.getenv("DB_CREDENTIALS")
if not DB_CREDENTIALS:
logger.error({"error": "no DB credentials found"})
INVALIDATE_CACHE_KEY = os.getenv("INVALIDATE_CACHE_KEY")
if not INVALIDATE_CACHE_KEY:
logger.error({"error": "no invalidate cache key found"})
todays_data = {} # stores full data set; global var to cache data with Lambda
EMAIL_TOPIC = os.getenv("EMAIL_TOPIC")
sns_client = boto3.client("sns")
from flask import Flask, request, jsonify
from flask_expects_json import expects_json
import requests, os
from flask_lambda import FlaskLambda
app = FlaskLambda(__name__)
schema = {
'type': 'object',
'properties': {
'numberone': {
'type': 'integer'
},
'numbertwo': {
'type': 'integer'
}
},
'required': ['numberone', 'numbertwo']
}
@app.route("/", methods=['GET'])
def main():
return "Welcome to CG Frontend Web Page"
@app.route("/postnumbers", methods=['POST'])
@expects_json(schema)
def postNumbers():
if request.json:
numberone = request.json.get('numberone', '')
numbertwo = request.json.get('numbertwo', '')
import docker
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()
try:
container = client.containers.create(
"ansible-template-ui",
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():
import json
import sys
from types import TracebackType
from typing import Type, Union
from flask_cors import CORS
import boto3
from boto3.dynamodb.conditions import Key, Attr
from botocore.exceptions import ClientError
from flask_lambda import FlaskLambda
from flask import request
import csv
import datetime
app = FlaskLambda(__name__)
CORS(app)
ddb = boto3.resource('dynamodb')
state_tax_table = ddb.Table('state_tax')
federal_tax_table = ddb.Table('federal_tax')
@app.route('/')
def index():
return json_response({"message": "1234Hello, world!"})
def compound_interest_calculator(original_principal, annual_interest, compound,
total_years, monthly_contribution):
# original_principal = int(input('Enter the starting principal: '))
#
# # Input the annual interest rate.
import json
from flask import request, Response
from flask_lambda import FlaskLambda
from vacinacao.service_layer.searcher import search_name
from vacinacao import settings
from flask_cors import CORS
app = FlaskLambda(__name__)
CORS(app)
@app.route("/", methods=["GET"])
def home():
html_template = open(f"{settings.ROOT_DIR}/templates/search.html").read()
html_content = html_template.replace(r"{{ BASE_URL }}", settings.BASE_URL)
return html_content, 200
@app.route("/search", methods=["POST"])
def search():
found = search_name(json.loads(request.data)["name"])
return Response(json.dumps(found),
headers={"Content-Type": "application/json"})
if __name__ == "__main__":
app.run(debug=True)
import os
import boto3
import flask
import json
from flask_lambda import FlaskLambda
from flask import request
app = FlaskLambda(__name__)
app.config["DEBUG"] = True
region = os.environ['AWS_REGION']
access_key_id = os.environ['AWS_ACCESS_KEY']
secret_access_key = os.environ['AWS_SECRET_KEY']
#os.environ['DEFAULT_REGION'] = "us-west-2"
session = boto3.Session(aws_access_key_id=access_key_id,
aws_secret_access_key=secret_access_key
#aws_session_token=SESSION_TOKEN
)
# Function for get_parameters
def get_parameters(param_key):
ssm = boto3.client('ssm', region_name=region)
response = ssm.get_parameters(Names=[
param_key,
], WithDecryption=True)
return response['Parameters'][0]['Value']
from flask import request, jsonify
from flask_lambda import FlaskLambda
app = FlaskLambda(__name__)
@app.route("/validate_email", methods=("POST",))
def validate_email():
data = request.get_json()
return jsonify({"data": data}), 200
import logging
from flask_lambda import FlaskLambda
from flask import request, jsonify, make_response, g
from flask_cors import CORS
from error_handler import error_handler, BadRequestException, UnauthorisedException
from random_string_gen import get_rand_string
from LinkObject import Link
from datetime import datetime
import json
import os
logging.basicConfig(level=logging.DEBUG, format='%(asctime)s [%(levelname)s] (%(threadName)-10s) %(message)s')
lambda_handler = FlaskLambda(__name__)
CORS(lambda_handler)
def success_json_response(payload):
"""Turns payload into a JSON HTTP200 response"""
response = make_response(jsonify(payload), 200)
response.headers["Content-type"] = "application/json"
return response
@lambda_handler.before_request
def get_user_details():
#g.username = "******"
try:
g.username = request.aws_event["requestContext"]["authorizer"]["claims"]["cognito:username"]
except KeyError as err:
print("No username found")
g.username = None
g.env = request.aws_event["stageVariables"]["env"]
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_app_lambda():
app = FlaskLambda(__name__)
return configure_app(app)
