def test_create_lambda_package(self):
# mock the pip.get_installed_distributions() to include a package in lambda_packages so that the code
# for zipping pre-compiled packages gets called
mock_named_tuple = collections.namedtuple('mock_named_tuple', ['project_name'])
mock_return_val = [mock_named_tuple(lambda_packages.keys()[0])] # choose name of 1st package in lambda_packages
with mock.patch('pip.get_installed_distributions', return_value=mock_return_val):
z = Zappa()
path = z.create_lambda_zip(handler_file=os.path.realpath(__file__))
self.assertTrue(os.path.isfile(path))
os.remove(path)
def test_create_lambda_package(self):
# mock the pip.get_installed_distributions() to include a package in lambda_packages so that the code
# for zipping pre-compiled packages gets called
mock_named_tuple = collections.namedtuple('mock_named_tuple', ['project_name'])
mock_return_val = [mock_named_tuple(lambda_packages.keys()[0])] # choose name of 1st package in lambda_packages
with mock.patch('pip.get_installed_distributions', return_value=mock_return_val):
z = Zappa()
path = z.create_lambda_zip(handler_file=os.path.realpath(__file__))
self.assertTrue(os.path.isfile(path))
os.remove(path)
def test_get_manylinux(self):
z = Zappa()
self.assertNotEqual(z.get_manylinux_wheel('pandas'), None)
self.assertEqual(z.get_manylinux_wheel('derpderpderpderp'), None)
# mock the pip.get_installed_distributions() to include a package in manylinux so that the code
# for zipping pre-compiled packages gets called
mock_named_tuple = collections.namedtuple('mock_named_tuple', ['project_name'])
mock_return_val = [mock_named_tuple('pandas')]
with mock.patch('pip.get_installed_distributions', return_value=mock_return_val):
z = Zappa()
path = z.create_lambda_zip(handler_file=os.path.realpath(__file__))
self.assertTrue(os.path.isfile(path))
os.remove(path)
def test_upload_remove_s3(self, session):
bucket_name = 'test_zappa_upload_s3'
z = Zappa(session)
zip_path = z.create_lambda_zip()
res = z.upload_to_s3(zip_path, bucket_name)
os.remove(zip_path)
self.assertTrue(res)
s3 = session.resource('s3')
# will throw ClientError with 404 if bucket doesn't exist
s3.meta.client.head_bucket(Bucket=bucket_name)
# will throw ClientError with 404 if object doesn't exist
s3.meta.client.head_object(
Bucket=bucket_name,
Key=zip_path,
)
res = z.remove_from_s3(zip_path, bucket_name)
self.assertTrue(res)
def test_upload_remove_s3(self, session):
bucket_name = 'test_zappa_upload_s3'
z = Zappa(session)
zip_path = z.create_lambda_zip(minify=False)
res = z.upload_to_s3(zip_path, bucket_name)
os.remove(zip_path)
self.assertTrue(res)
s3 = session.resource('s3')
# will throw ClientError with 404 if bucket doesn't exist
s3.meta.client.head_bucket(Bucket=bucket_name)
# will throw ClientError with 404 if object doesn't exist
s3.meta.client.head_object(
Bucket=bucket_name,
Key=zip_path,
)
res = z.remove_from_s3(zip_path, bucket_name)
self.assertTrue(res)
fail = z.upload_to_s3('/tmp/this_isnt_real', bucket_name)
self.assertFalse(fail)
class ZappaCommand(BaseCommand):
# Management command
can_import_settings = True
requires_system_checks = False
# Zappa settings
zappa = None
zappa_settings = None
api_stage = None
project_name = None
lambda_name = None
api_name = None
s3_bucket_name = None
settings_file = None
zip_path = None
vpc_config = None
memory_size = None
timeout = None
help = '''Deploy this project to AWS with Zappa.'''
def add_arguments(self, parser):
parser.add_argument('environment', nargs='+', type=str)
def __init__(self, *args, **kwargs):
super(ZappaCommand, self).__init__(*args, **kwargs)
self.zappa = Zappa()
def require_settings(self, args, options):
"""
Load the ZAPPA_SETTINGS as we expect it.
"""
if not options.has_key('environment'):
print(
"You must call deploy with an environment name. \n python manage.py deploy <environment>")
raise ImproperlyConfigured
from django.conf import settings
if not 'ZAPPA_SETTINGS' in dir(settings):
print(
"Please define your ZAPPA_SETTINGS in your settings file before deploying.")
raise ImproperlyConfigured
self.zappa_settings = settings.ZAPPA_SETTINGS
# Set your configuration
self.project_name = os.path.abspath(settings.BASE_DIR).split(os.sep)[-1]
if type(options['environment']) == list:
self.api_stage = options['environment'][0]
else:
self.api_stage = options['environment']
self.lambda_name = self.zappa_settings[self.api_stage].get('lambda_function', slugify(
self.project_name + '-' + self.api_stage).replace("_", "-"))
if self.api_stage not in self.zappa_settings.keys():
print("Please make sure that the environment '" + self.api_stage +
"' is defined in your ZAPPA_SETTINGS in your settings file before deploying.")
raise ImproperlyConfigured
self.api_name = self.zappa_settings[self.api_stage].get('api_name', self.lambda_name)
# Load environment-specific settings
self.s3_bucket_name = self.zappa_settings[self.api_stage]['s3_bucket']
self.vpc_config = self.zappa_settings[
self.api_stage].get('vpc_config', {})
self.memory_size = self.zappa_settings[
self.api_stage].get('memory_size', 512)
self.timeout = self.zappa_settings[
self.api_stage].get('timeout', 30)
custom_settings = [
'http_methods',
'parameter_depth',
'integration_response_codes',
'method_response_codes',
'role_name',
'aws_region'
]
for setting in custom_settings:
if self.zappa_settings[self.api_stage].has_key(setting):
setattr(self.zappa, setting, self.zappa_settings[
self.api_stage][setting])
def get_django_settings_file(self):
if not self.get_settings_location().startswith('s3://'):
self.settings_file = self.zappa_settings[
self.api_stage]['settings_file']
if '~' in self.settings_file:
self.settings_file = self.settings_file.replace(
'~', os.path.expanduser('~'))
self.check_settings_file()
else:
self.settings_file = self.download_from_s3(*self.parse_s3_url(self.get_settings_location()))
self.check_settings_file()
def check_settings_file(self):
"""
Checks whether the settings file specified is actually a file.
"""
if not os.path.isfile(self.settings_file):
print("Please make sure your settings_file is properly defined.")
raise ImproperlyConfigured
def get_settings_location(self):
"""
Returns the value of the settings file location as specified in the
json file.
:return:
"""
return self.zappa_settings[self.api_stage]['settings_file']
def download_from_s3(self, bucket_name, s3_key,
output_filename='temp_zappa_settings.py'):
"""
Download a file from S3
:param bucket_name: Name of the S3 bucket (string)
:param s3_key: Name of the file hosted on S3 (string)
:param output_filename: Name of the file the download operation
will create (string)
:return: False or the value of output_filename
"""
s3 = boto3.resource('s3')
bucket = s3.Bucket(bucket_name)
try:
s3.meta.client.head_object(Bucket=bucket_name, Key=s3_key)
except botocore.exceptions.ClientError:
return False
print(u'Downloading the settings file ({0}) from S3'.format(s3_key))
new_file = bucket.download_file(s3_key, output_filename)
return output_filename
def parse_s3_url(self, s3_url):
"""
Parse the S3 url. Format: s3://mybucket:path/to/my/key
Example: s3://settings-bucket:/production_settings.py
:param s3_url: Path to the file hosted on S3
:return:
"""
return s3_url.replace('s3://', '').split(':')
def load_credentials(self):
session = None
profile_name = self.zappa_settings[self.api_stage].get('profile_name')
region_name = self.zappa_settings[self.api_stage].get('aws_region')
if profile_name is not None:
session = boto3.Session(profile_name=profile_name, region_name=region_name)
self.zappa.load_credentials(session)
def create_package(self):
"""
Ensure that the package can be properly configured,
and then create it.
"""
# Create the Lambda zip package (includes project and virtualenvironment)
# Also define the path the handler file so it can be copied to the zip
# root for Lambda.
current_file = os.path.dirname(os.path.abspath(
inspect.getfile(inspect.currentframe())))
handler_file = os.sep.join(current_file.split(os.sep)[
0:-2]) + os.sep + 'handler.py'
exclude = ['static', 'media']
self.zip_path = self.zappa.create_lambda_zip(
self.lambda_name,
handler_file=handler_file,
use_precompiled_packages=self.zappa_settings.get('use_precompiled_packages', True),
exclude=exclude
)
# Add this environment's Django settings to that zipfile
with open(self.settings_file, 'r') as f:
contents = f.read()
all_contents = contents
if not self.zappa_settings[self.api_stage].has_key('domain'):
script_name = self.api_stage
else:
script_name = ''
all_contents = all_contents + \
'\n# Automatically added by Zappa:\nSCRIPT_NAME=\'/' + script_name + '\'\n'
f.close()
with open('zappa_settings.py', 'w') as f:
f.write(all_contents)
with zipfile.ZipFile(self.zip_path, 'a') as lambda_zip:
lambda_zip.write('zappa_settings.py', 'zappa_settings.py')
lambda_zip.close()
os.unlink('zappa_settings.py')
def remove_s3_local_settings(self):
# Remove the settings file if downloaded from S3
if self.get_settings_location().startswith('s3://'):
os.remove(self.settings_file)
def remove_local_zip(self):
"""
Remove our local zip file.
"""
if self.zappa_settings[self.api_stage].get('delete_zip', True):
os.remove(self.zip_path)
def remove_uploaded_zip(self):
"""
Remove the local and S3 zip file after uploading and updating.
"""
# Remove the uploaded zip from S3, because it is now registered..
self.zappa.remove_from_s3(self.zip_path, self.s3_bucket_name)
# Finally, delete the local copy our zip package
self.remove_local_zip()
def handle(self, *args, **options):
"""
Execute the command.
"""
if not options.has_key('environment'):
print("You must call deploy with an environment name. \n python manage.py deploy <environment>")
return
from django.conf import settings
if not 'ZAPPA_SETTINGS' in dir(settings):
print("Please define your ZAPPA_SETTINGS in your settings file before deploying.")
return
zappa_settings = settings.ZAPPA_SETTINGS
# Set your configuration
project_name = settings.BASE_DIR.split(os.sep)[-1]
api_stage = options['environment'][0]
if api_stage not in zappa_settings.keys():
print("Please make sure that the environment '" + api_stage + "' is defined in your ZAPPA_SETTINGS in your settings file before deploying.")
return
# Make your Zappa object
zappa = Zappa()
# Load environment-specific settings
s3_bucket_name = zappa_settings[api_stage]['s3_bucket']
settings_file = zappa_settings[api_stage]['settings_file']
if '~' in settings_file:
settings_file = settings_file.replace('~', os.path.expanduser('~'))
if not os.path.isfile(settings_file):
print("Please make sure your settings_file is properly defined.")
return
custom_settings = [
'http_methods',
'parameter_depth',
'integration_response_codes',
'method_response_codes',
'role_name',
'aws_region'
]
for setting in custom_settings:
if zappa_settings[api_stage].has_key(setting):
setattr(zappa, setting, zappa_settings[api_stage][setting])
# Load your AWS credentials from ~/.aws/credentials
zappa.load_credentials()
# Create the Lambda zip package (includes project and virtualenvironment)
# Also define the path the handler file so it can be copied to the zip root for Lambda.
current_file = os.path.dirname(os.path.abspath(inspect.getfile(inspect.currentframe())))
handler_file = os.sep.join(current_file.split(os.sep)[0:-2]) + os.sep + 'handler.py'
lambda_name = project_name + '-' + api_stage
zip_path = zappa.create_lambda_zip(lambda_name, handler_file=handler_file)
#Add this environment's Django settings to that zipfile
with open(settings_file, 'r') as f:
contents = f.read()
all_contents = contents + '\n# Automatically added by Zappa:\nSCRIPT_NAME=\'/' + api_stage + '\'\n'
f.close()
with open('zappa_settings.py', 'w') as f:
f.write(all_contents)
with zipfile.ZipFile(zip_path, 'a') as lambda_zip:
lambda_zip.write('zappa_settings.py', 'zappa_settings.py')
lambda_zip.close()
os.unlink('zappa_settings.py')
# Upload it to S3
zip_arn = zappa.upload_to_s3(zip_path, s3_bucket_name)
# Register the Lambda function with that zip as the source
# You'll also need to define the path to your lambda_handler code.
lambda_arn = zappa.update_lambda_function(s3_bucket_name, zip_path, lambda_name)
# Get the URL!
endpoint_url = zappa.get_api_url(lambda_name)
# Finally, delete the local copy our zip package
os.remove(zip_path)
# Remove the uploaded zip from S3, because it is now registered..
zappa.remove_from_s3(zip_path, s3_bucket_name)
print("Your updated Zappa deployment is live!")
return
def handle(self, *args, **options):
"""
Execute the command.
"""
if not options.has_key('environment'):
print("You must call deploy with an environment name. \n python manage.py deploy <environment>")
return
from django.conf import settings
if not 'ZAPPA_SETTINGS' in dir(settings):
print("Please define your ZAPPA_SETTINGS in your settings file before deploying.")
return
zappa_settings = settings.ZAPPA_SETTINGS
# Set your configuration
project_name = settings.BASE_DIR.split(os.sep)[-1]
api_stage = options['environment'][0]
if api_stage not in zappa_settings.keys():
print("Please make sure that the environment '" + api_stage + "' is defined in your ZAPPA_SETTINGS in your settings file before deploying.")
return
# Make your Zappa object
zappa = Zappa()
# Load environment-specific settings
s3_bucket_name = zappa_settings[api_stage]['s3_bucket']
vpc_config = zappa_settings[api_stage].get('vpc_config', {})
memory_size = zappa_settings[api_stage].get('memory_size', 512)
settings_file = zappa_settings[api_stage]['settings_file']
if '~' in settings_file:
settings_file = settings_file.replace('~', os.path.expanduser('~'))
if not os.path.isfile(settings_file):
print("Please make sure your settings_file is properly defined.")
return
custom_settings = [
'http_methods',
'parameter_depth',
'integration_response_codes',
'method_response_codes',
'role_name',
'aws_region'
]
for setting in custom_settings:
if zappa_settings[api_stage].has_key(setting):
setattr(zappa, setting, zappa_settings[api_stage][setting])
# Load your AWS credentials from ~/.aws/credentials
zappa.load_credentials()
# Make sure the necessary IAM execution roles are available
zappa.create_iam_roles()
# Create the Lambda zip package (includes project and virtualenvironment)
# Also define the path the handler file so it can be copied to the zip root for Lambda.
current_file = os.path.dirname(os.path.abspath(inspect.getfile(inspect.currentframe())))
handler_file = os.sep.join(current_file.split(os.sep)[0:-2]) + os.sep + 'handler.py'
lambda_name = project_name + '-' + api_stage
zip_path = zappa.create_lambda_zip(lambda_name, handler_file=handler_file)
# Add this environment's Django settings to that zipfile
with open(settings_file, 'r') as f:
contents = f.read()
all_contents = contents
if not zappa_settings[api_stage].has_key('domain'):
script_name = api_stage
else:
script_name = ''
if not "ZappaMiddleware" in all_contents:
print("\n\nWARNING!\n")
print("You do not have ZappaMiddleware in your remote settings's MIDDLEWARE_CLASSES.\n")
print("This means that some aspects of your application may not work!\n\n")
all_contents = all_contents + '\n# Automatically added by Zappa:\nSCRIPT_NAME=\'/' + script_name + '\'\n'
f.close()
with open('zappa_settings.py', 'w') as f:
f.write(all_contents)
with zipfile.ZipFile(zip_path, 'a') as lambda_zip:
lambda_zip.write('zappa_settings.py', 'zappa_settings.py')
lambda_zip.close()
os.unlink('zappa_settings.py')
# Upload it to S3
zip_arn = zappa.upload_to_s3(zip_path, s3_bucket_name)
# Register the Lambda function with that zip as the source
# You'll also need to define the path to your lambda_handler code.
lambda_arn = zappa.create_lambda_function(bucket=s3_bucket_name,
s3_key=zip_path,
function_name=lambda_name,
handler='handler.lambda_handler',
vpc_config=vpc_config,
memory_size=memory_size)
# Create and configure the API Gateway
api_id = zappa.create_api_gateway_routes(lambda_arn, lambda_name)
# Deploy the API!
endpoint_url = zappa.deploy_api_gateway(api_id, api_stage)
# Finally, delete the local copy our zip package
if zappa_settings[api_stage].get('delete_zip', True):
os.remove(zip_path)
# Remove the uploaded zip from S3, because it is now registered..
zappa.remove_from_s3(zip_path, s3_bucket_name)
if zappa_settings[api_stage].get('touch', True):
requests.get(endpoint_url)
print("Your Zappa deployment is live!: " + endpoint_url)
return
def test_create_lambda_package(self):
self.assertTrue(True)
z = Zappa()
path = z.create_lambda_zip(handler_file=os.path.realpath(__file__))
self.assertTrue(os.path.isfile(path))
os.remove(path)
def handle(self, *args, **options):
"""
Execute the command.
"""
if not options.has_key("environment"):
print("You must call deploy with an environment name. \n python manage.py deploy <environment>")
return
from django.conf import settings
if not "ZAPPA_SETTINGS" in dir(settings):
print("Please define your ZAPPA_SETTINGS in your settings file before deploying.")
return
zappa_settings = settings.ZAPPA_SETTINGS
# Set your configuration
project_name = settings.BASE_DIR.split(os.sep)[-1]
api_stage = options["environment"][0]
if api_stage not in zappa_settings.keys():
print(
"Please make sure that the environment '"
+ api_stage
+ "' is defined in your ZAPPA_SETTINGS in your settings file before deploying."
)
return
# Make your Zappa object
zappa = Zappa()
# Load environment-specific settings
s3_bucket_name = zappa_settings[api_stage]["s3_bucket"]
settings_file = zappa_settings[api_stage]["settings_file"]
if "~" in settings_file:
settings_file = settings_file.replace("~", os.path.expanduser("~"))
if not os.path.isfile(settings_file):
print("Please make sure your settings_file is properly defined.")
return
custom_settings = [
"http_methods",
"parameter_depth",
"integration_response_codes",
"method_response_codes",
"role_name",
"aws_region",
]
for setting in custom_settings:
if zappa_settings[api_stage].has_key(setting):
setattr(zappa, setting, zappa_settings[api_stage][setting])
# Load your AWS credentials from ~/.aws/credentials
zappa.load_credentials()
# Create the Lambda zip package (includes project and virtualenvironment)
# Also define the path the handler file so it can be copied to the zip root for Lambda.
current_file = os.path.dirname(os.path.abspath(inspect.getfile(inspect.currentframe())))
handler_file = os.sep.join(current_file.split(os.sep)[0:-2]) + os.sep + "handler.py"
lambda_name = project_name + "-" + api_stage
zip_path = zappa.create_lambda_zip(lambda_name, handler_file=handler_file)
# Add this environment's Django settings to that zipfile
with open(settings_file, "r") as f:
contents = f.read()
all_contents = contents
if not zappa_settings[api_stage].has_key("domain"):
script_name = api_stage
else:
script_name = ""
if not "ZappaMiddleware" in all_contents:
print("\n\nWARNING!\n")
print("You do not have ZappaMiddleware in your remote settings's MIDDLEWARE_CLASSES.\n")
print("This means that some aspects of your application may not work!\n\n")
all_contents = all_contents + "\n# Automatically added by Zappa:\nSCRIPT_NAME='/" + script_name + "'\n"
f.close()
with open("zappa_settings.py", "w") as f:
f.write(all_contents)
with zipfile.ZipFile(zip_path, "a") as lambda_zip:
lambda_zip.write("zappa_settings.py", "zappa_settings.py")
lambda_zip.close()
os.unlink("zappa_settings.py")
# Upload it to S3
zip_arn = zappa.upload_to_s3(zip_path, s3_bucket_name)
# Register the Lambda function with that zip as the source
# You'll also need to define the path to your lambda_handler code.
lambda_arn = zappa.update_lambda_function(s3_bucket_name, zip_path, lambda_name)
# Finally, delete the local copy our zip package
if zappa_settings[api_stage].get("delete_zip", True):
os.remove(zip_path)
# Remove the uploaded zip from S3, because it is now registered..
zappa.remove_from_s3(zip_path, s3_bucket_name)
print("Your updated Zappa deployment is live!")
return
def handle(self, *args, **options):
"""
Execute the command.
"""
if not options.has_key('environment'):
print("You must call deploy with an environment name. \n python manage.py deploy <environment>")
return
from django.conf import settings
if not 'ZAPPA_SETTINGS' in dir(settings):
print("Please define your ZAPPA_SETTINGS in your settings file before deploying.")
return
zappa_settings = settings.ZAPPA_SETTINGS
# Set your configuration
project_name = settings.BASE_DIR.split(os.sep)[-1]
api_stage = options['environment'][0]
if api_stage not in zappa_settings.keys():
print("Please make sure that the environment '" + api_stage + "' is defined in your ZAPPA_SETTINGS in your settings file before deploying.")
return
# Make your Zappa object
zappa = Zappa()
# Load environment-specific settings
s3_bucket_name = zappa_settings[api_stage]['s3_bucket']
settings_file = zappa_settings[api_stage]['settings_file']
if '~' in settings_file:
settings_file = settings_file.replace('~', os.path.expanduser('~'))
if not os.path.isfile(settings_file):
print("Please make sure your settings_file is properly defined.")
return
custom_settings = [
'http_methods',
'parameter_depth',
'integration_response_codes',
'method_response_codes',
'role_name',
'aws_region'
]
for setting in custom_settings:
if zappa_settings[api_stage].has_key(setting):
setattr(zappa, setting, zappa_settings[api_stage][setting])
# Load your AWS credentials from ~/.aws/credentials
zappa.load_credentials()
# Create the Lambda zip package (includes project and virtualenvironment)
# Also define the path the handler file so it can be copied to the zip root for Lambda.
current_file = os.path.dirname(os.path.abspath(inspect.getfile(inspect.currentframe())))
handler_file = os.sep.join(current_file.split(os.sep)[0:-2]) + os.sep + 'handler.py'
lambda_name = project_name + '-' + api_stage
zip_path = zappa.create_lambda_zip(lambda_name, handler_file=handler_file)
# Add this environment's Django settings to that zipfile
with zipfile.ZipFile(zip_path, 'a') as lambda_zip:
lambda_zip.write(settings_file, 'zappa_settings.py')
lambda_zip.close()
# Upload it to S3
zip_arn = zappa.upload_to_s3(zip_path, s3_bucket_name)
# Register the Lambda function with that zip as the source
# You'll also need to define the path to your lambda_handler code.
lambda_arn = zappa.update_lambda_function(s3_bucket_name, zip_path, lambda_name)
# Get the URL!
endpoint_url = zappa.get_api_url(lambda_name)
# Finally, delete the local copy our zip package
os.remove(zip_path)
# Remove the uploaded zip from S3, because it is now registered..
zappa.remove_from_s3(zip_path, s3_bucket_name)
print("Your updated Zappa deployment is live!")
return
class ZappaCommand(BaseCommand):
# Management command
can_import_settings = True
requires_system_checks = False
# Zappa settings
zappa = None
zappa_settings = None
api_stage = None
project_name = None
lambda_name = None
s3_bucket_name = None
settings_file = None
zip_path = None
vpc_config = None
memory_size = None
timeout = None
help = '''Deploy this project to AWS with Zappa.'''
def add_arguments(self, parser):
parser.add_argument('environment', nargs='+', type=str)
def __init__(self, *args, **kwargs):
super(ZappaCommand, self).__init__(*args, **kwargs)
self.zappa = Zappa()
def require_settings(self, args, options):
"""
Load the ZAPPA_SETTINGS as we expect it.
"""
if not options.has_key('environment'):
print(
"You must call deploy with an environment name. \n python manage.py deploy <environment>"
)
raise ImproperlyConfigured
from django.conf import settings
if not 'ZAPPA_SETTINGS' in dir(settings):
print(
"Please define your ZAPPA_SETTINGS in your settings file before deploying."
)
raise ImproperlyConfigured
self.zappa_settings = settings.ZAPPA_SETTINGS
# Set your configuration
self.project_name = os.path.abspath(settings.BASE_DIR).split(
os.sep)[-1]
if type(options['environment']) == list:
self.api_stage = options['environment'][0]
else:
self.api_stage = options['environment']
self.lambda_name = slugify(self.project_name + '-' +
self.api_stage).replace("_", "-")
if self.api_stage not in self.zappa_settings.keys():
print(
"Please make sure that the environment '" + self.api_stage +
"' is defined in your ZAPPA_SETTINGS in your settings file before deploying."
)
raise ImproperlyConfigured
# Load environment-specific settings
self.s3_bucket_name = self.zappa_settings[self.api_stage]['s3_bucket']
self.vpc_config = self.zappa_settings[self.api_stage].get(
'vpc_config', {})
self.memory_size = self.zappa_settings[self.api_stage].get(
'memory_size', 512)
self.timeout = self.zappa_settings[self.api_stage].get('timeout', 30)
custom_settings = [
'http_methods', 'parameter_depth', 'integration_response_codes',
'method_response_codes', 'role_name', 'aws_region'
]
for setting in custom_settings:
if self.zappa_settings[self.api_stage].has_key(setting):
setattr(self.zappa, setting,
self.zappa_settings[self.api_stage][setting])
def get_django_settings_file(self):
if not self.get_settings_location().startswith('s3://'):
self.settings_file = self.zappa_settings[
self.api_stage]['settings_file']
if '~' in self.settings_file:
self.settings_file = self.settings_file.replace(
'~', os.path.expanduser('~'))
self.check_settings_file()
else:
self.settings_file = self.download_from_s3(
*self.parse_s3_url(self.get_settings_location()))
self.check_settings_file()
def check_settings_file(self):
"""
Checks whether the settings file specified is actually a file.
"""
if not os.path.isfile(self.settings_file):
print("Please make sure your settings_file is properly defined.")
raise ImproperlyConfigured
def get_settings_location(self):
"""
Returns the value of the settings file location as specified in the
json file.
:return:
"""
return self.zappa_settings[self.api_stage]['settings_file']
def download_from_s3(self,
bucket_name,
s3_key,
output_filename='temp_zappa_settings.py'):
"""
Download a file from S3
:param bucket_name: Name of the S3 bucket (string)
:param s3_key: Name of the file hosted on S3 (string)
:param output_filename: Name of the file the download operation
will create (string)
:return: False or the value of output_filename
"""
s3 = boto3.resource('s3')
bucket = s3.Bucket(bucket_name)
try:
s3.meta.client.head_object(Bucket=bucket_name, Key=s3_key)
except botocore.exceptions.ClientError:
return False
print(u'Downloading the settings file ({0}) from S3'.format(s3_key))
new_file = bucket.download_file(s3_key, output_filename)
return output_filename
def parse_s3_url(self, s3_url):
"""
Parse the S3 url. Format: s3://mybucket:path/to/my/key
Example: s3://settings-bucket:/production_settings.py
:param s3_url: Path to the file hosted on S3
:return:
"""
return s3_url.replace('s3://', '').split(':')
def load_credentials(self):
session = None
profile_name = self.zappa_settings[self.api_stage].get('profile_name')
region_name = self.zappa_settings[self.api_stage].get('aws_region')
if profile_name is not None:
session = boto3.Session(profile_name=profile_name,
region_name=region_name)
self.zappa.load_credentials(session)
def create_package(self):
"""
Ensure that the package can be properly configured,
and then create it.
"""
# Create the Lambda zip package (includes project and virtualenvironment)
# Also define the path the handler file so it can be copied to the zip
# root for Lambda.
current_file = os.path.dirname(
os.path.abspath(inspect.getfile(inspect.currentframe())))
handler_file = os.sep.join(current_file.split(
os.sep)[0:-2]) + os.sep + 'handler.py'
exclude = ['static', 'media']
self.zip_path = self.zappa.create_lambda_zip(
self.lambda_name,
handler_file=handler_file,
use_precompiled_packages=self.zappa_settings.get(
'use_precompiled_packages', True),
exclude=exclude)
# Add this environment's Django settings to that zipfile
with open(self.settings_file, 'r') as f:
contents = f.read()
all_contents = contents
if not self.zappa_settings[self.api_stage].has_key('domain'):
script_name = self.api_stage
else:
script_name = ''
all_contents = all_contents + \
'\n# Automatically added by Zappa:\nSCRIPT_NAME=\'/' + script_name + '\'\n'
f.close()
with open('zappa_settings.py', 'w') as f:
f.write(all_contents)
with zipfile.ZipFile(self.zip_path, 'a') as lambda_zip:
lambda_zip.write('zappa_settings.py', 'zappa_settings.py')
lambda_zip.close()
os.unlink('zappa_settings.py')
def remove_s3_local_settings(self):
#Remove the settings file if downloaded from S3
if self.get_settings_location().startswith('s3://'):
os.remove(self.settings_file)
def remove_local_zip(self):
"""
Remove our local zip file.
"""
if self.zappa_settings[self.api_stage].get('delete_zip', True):
os.remove(self.zip_path)
def remove_uploaded_zip(self):
"""
Remove the local and S3 zip file after uploading and updating.
"""
# Remove the uploaded zip from S3, because it is now registered..
self.zappa.remove_from_s3(self.zip_path, self.s3_bucket_name)
# Finally, delete the local copy our zip package
self.remove_local_zip()
class ZappaCommand(BaseCommand):
# Management command
can_import_settings = True
requires_system_checks = False
# Zappa settings
zappa = None
zappa_settings = None
api_stage = None
project_name = None
lambda_name = None
s3_bucket_name = None
settings_file = None
zip_path = None
vpc_config = None
memory_size = None
help = '''Deploy this project to AWS with Zappa.'''
def add_arguments(self, parser):
parser.add_argument('environment', nargs='+', type=str)
def __init__(self, *args, **kwargs):
super(ZappaCommand, self).__init__(*args, **kwargs)
self.zappa = Zappa()
def require_settings(self, args, options):
"""
Load the ZAPPA_SETTINGS as we expect it.
"""
if not options.has_key('environment'):
print(
"You must call deploy with an environment name. \n python manage.py deploy <environment>")
raise ImproperlyConfigured
from django.conf import settings
if not 'ZAPPA_SETTINGS' in dir(settings):
print(
"Please define your ZAPPA_SETTINGS in your settings file before deploying.")
raise ImproperlyConfigured
self.zappa_settings = settings.ZAPPA_SETTINGS
# Set your configuration
self.project_name = os.path.abspath(settings.BASE_DIR).split(os.sep)[-1]
if type(options['environment']) == list:
self.api_stage = options['environment'][0]
else:
self.api_stage = options['environment']
self.lambda_name = self.project_name + '-' + self.api_stage
if self.api_stage not in self.zappa_settings.keys():
print("Please make sure that the environment '" + self.api_stage +
"' is defined in your ZAPPA_SETTINGS in your settings file before deploying.")
raise ImproperlyConfigured
# Load environment-specific settings
self.s3_bucket_name = self.zappa_settings[self.api_stage]['s3_bucket']
self.vpc_config = self.zappa_settings[
self.api_stage].get('vpc_config', {})
self.memory_size = self.zappa_settings[
self.api_stage].get('memory_size', 512)
self.settings_file = self.zappa_settings[
self.api_stage]['settings_file']
if '~' in self.settings_file:
self.settings_file = self.settings_file.replace(
'~', os.path.expanduser('~'))
if not os.path.isfile(self.settings_file):
print("Please make sure your settings_file is properly defined.")
raise ImproperlyConfigured
custom_settings = [
'http_methods',
'parameter_depth',
'integration_response_codes',
'method_response_codes',
'role_name',
'aws_region'
]
for setting in custom_settings:
if self.zappa_settings[self.api_stage].has_key(setting):
setattr(self.zappa, setting, self.zappa_settings[
self.api_stage][setting])
def create_package(self):
"""
Ensure that the package can be properly configured,
and then create it.
"""
# Create the Lambda zip package (includes project and virtualenvironment)
# Also define the path the handler file so it can be copied to the zip
# root for Lambda.
current_file = os.path.dirname(os.path.abspath(
inspect.getfile(inspect.currentframe())))
handler_file = os.sep.join(current_file.split(os.sep)[
0:-2]) + os.sep + 'handler.py'
exclude = ['static', 'media']
self.zip_path = self.zappa.create_lambda_zip(
self.lambda_name,
handler_file=handler_file,
use_precompiled_packages=self.zappa_settings.get('use_precompiled_packages', True),
exclude=exclude
)
# Add this environment's Django settings to that zipfile
with open(self.settings_file, 'r') as f:
contents = f.read()
all_contents = contents
if not self.zappa_settings[self.api_stage].has_key('domain'):
script_name = self.api_stage
else:
script_name = ''
if not "ZappaMiddleware" in all_contents:
print("\n\nWARNING!\n")
print(
"You do not have ZappaMiddleware in your remote settings's MIDDLEWARE_CLASSES.\n")
print(
"This means that some aspects of your application may not work!\n\n")
all_contents = all_contents + \
'\n# Automatically added by Zappa:\nSCRIPT_NAME=\'/' + script_name + '\'\n'
f.close()
with open('zappa_settings.py', 'w') as f:
f.write(all_contents)
with zipfile.ZipFile(self.zip_path, 'a') as lambda_zip:
lambda_zip.write('zappa_settings.py', 'zappa_settings.py')
lambda_zip.close()
os.unlink('zappa_settings.py')
def remove_local_zip(self):
"""
Remove our local zip file.
"""
if self.zappa_settings[self.api_stage].get('delete_zip', True):
os.remove(self.zip_path)
def remove_uploaded_zip(self):
"""
Remove the local and S3 zip file after uploading and updating.
"""
# Remove the uploaded zip from S3, because it is now registered..
self.zappa.remove_from_s3(self.zip_path, self.s3_bucket_name)
# Finally, delete the local copy our zip package
self.remove_local_zip()
def test_create_lambda_package(self):
self.assertTrue(True)
z = Zappa()
path = z.create_lambda_zip()
self.assertTrue(os.path.isfile(path))
os.remove(path)
def test_create_lambda_package(self):
self.assertTrue(True)
z = Zappa()
path = z.create_lambda_zip(handler_file=os.path.realpath(__file__))
self.assertTrue(os.path.isfile(path))
os.remove(path)
def test_create_lambda_package(self):
self.assertTrue(True)
z = Zappa()
path = z.create_lambda_zip()
self.assertTrue(os.path.isfile(path))
os.remove(path)
def handle(self, *args, **options):
"""
Execute the command.
"""
if not options.has_key('environment'):
print("You must call deploy with an environment name. \n python manage.py deploy <environment>")
return
from django.conf import settings
if not 'ZAPPA_SETTINGS' in dir(settings):
print("Please define your ZAPPA_SETTINGS in your settings file before deploying.")
return
zappa_settings = settings.ZAPPA_SETTINGS
# Set your configuration
project_name = settings.BASE_DIR.split(os.sep)[-1]
api_stage = options['environment'][0]
if api_stage not in zappa_settings.keys():
print("Please make sure that the environment '" + api_stage + "' is defined in your ZAPPA_SETTINGS in your settings file before deploying.")
return
# Make your Zappa object
zappa = Zappa()
# Load environment-specific settings
s3_bucket_name = zappa_settings[api_stage]['s3_bucket']
settings_file = zappa_settings[api_stage]['settings_file']
if '~' in settings_file:
settings_file = settings_file.replace('~', os.path.expanduser('~'))
if not os.path.isfile(settings_file):
print("Please make sure your settings_file is properly defined.")
return
custom_settings = [
'http_methods',
'parameter_depth',
'integration_response_codes',
'method_response_codes',
'role_name',
'aws_region'
]
for setting in custom_settings:
if zappa_settings[api_stage].has_key(setting):
setattr(zappa, setting, zappa_settings[api_stage][setting])
# Load your AWS credentials from ~/.aws/credentials
zappa.load_credentials()
# Make sure the necessary IAM execution roles are available
zappa.create_iam_roles()
# Create the Lambda zip package (includes project and virtualenvironment)
# Also define the path the handler file so it can be copied to the zip root for Lambda.
current_file = os.path.dirname(os.path.abspath(inspect.getfile(inspect.currentframe())))
handler_file = os.sep.join(current_file.split(os.sep)[0:-2]) + os.sep + 'handler.py'
lambda_name = project_name + '-' + api_stage
zip_path = zappa.create_lambda_zip(lambda_name, handler_file=handler_file)
# Add this environment's Django settings to that zipfile
with open(settings_file, 'r') as f:
contents = f.read()
all_contents = contents
if not zappa_settings[api_stage].has_key('domain'):
script_name = api_stage
else:
script_name = ''
if not "ZappaMiddleware" in all_contents:
print("\n\nWARNING!\n")
print("You do not have ZappaMiddleware in your remote settings's MIDDLEWARE_CLASSES.\n")
print("This means that some aspects of your application may not work!\n\n")
all_contents = all_contents + '\n# Automatically added by Zappa:\nSCRIPT_NAME=\'/' + script_name + '\'\n'
f.close()
with open('zappa_settings.py', 'w') as f:
f.write(all_contents)
with zipfile.ZipFile(zip_path, 'a') as lambda_zip:
lambda_zip.write('zappa_settings.py', 'zappa_settings.py')
lambda_zip.close()
os.unlink('zappa_settings.py')
# Upload it to S3
zip_arn = zappa.upload_to_s3(zip_path, s3_bucket_name)
# Register the Lambda function with that zip as the source
# You'll also need to define the path to your lambda_handler code.
lambda_arn = zappa.create_lambda_function(s3_bucket_name, zip_path, lambda_name, 'handler.lambda_handler')
# Create and configure the API Gateway
delay = zappa_settings[api_stage].get('deploy_delay', 1)
api_id = zappa.create_api_gateway_routes(lambda_arn, lambda_name, delay)
# Deploy the API!
endpoint_url = zappa.deploy_api_gateway(api_id, api_stage)
# Finally, delete the local copy our zip package
if zappa_settings[api_stage].get('delete_zip', True):
os.remove(zip_path)
# Remove the uploaded zip from S3, because it is now registered..
zappa.remove_from_s3(zip_path, s3_bucket_name)
if zappa_settings[api_stage].get('touch', True):
requests.get(endpoint_url)
print("Your Zappa deployment is live!: " + endpoint_url)
return
