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)