Jonas Haag jonashaag

AWS Fargate Docker Simple Deployment Setup with SSL termination

How to:

create a Docker-based AWS Fargate/ECS deployment
without the Docker containers having a public IP
with an Application Load Balancer as reverse proxy / SSL termination proxy sitting in front of the containers

For Fargate/ECS to be able to access your Docker images hosted on ECR (or somewhere else) you'll have to allow outbound internet access to the Fargate subnets. Here's how you do it.

	def cirm(y, s, K=10, C=0.1, flat=True):
	y = librosa.core.stft(y.astype('float64'), 256, 64).astype('complex128')
	s = librosa.core.stft(s.astype('float64'), 256, 64).astype('complex128')
	mr = (np.real(y) * np.real(s) + np.imag(y) * np.imag(s))/(np.real(y)2 + np.imag(y)2)
	mi = (np.real(y) * np.imag(s) - np.imag(y) * np.real(s))/(np.real(y)2 + np.imag(y)2)
	m = mr + 1j * mi
	if flat:
	return m
	else:
	return K * ((1 - np.exp(-C * m))/(1 + np.exp(-C * m)))

	import librosa
	from scipy.signal import butter, lfilter

	SR = 8000
	NFFT = 256 # change ~proportionally to SR


	def butter_bandpass(lowcut, highcut, fs, order=5):
	nyq = 0.5 * fs
	low = lowcut / nyq

	import requests
	import os
	url = 'http://' + os.environ['COLAB_TPU_ADDR'].split(':')[0] + ':8475/requestversion/2.2.0-dev20200311'
	resp = requests.post(url)
	print(resp)
	%pip install tf-nightly==2.2.0-dev20200311

	if __name__ == '__main__':
	import dask.distributed

	client = dask.distributed.Client()

	queue = dask.distributed.Queue('queue1')

	def f():
	return 42

	class PickleableCtypesFuncPtr:
	"""A version of a ctypes._FuncPtr that can be pickled. The shared library
	must be available in the depickling environment.
	"""
	def __init__(self, dll_type, lib, name):
	self.__setstate__((dll_type, lib, name))

	def __setstate__(self, state):
	self.state = state
	dll_type, lib, func = self.state

	# Use libc in ctypes "PyDLL" mode, which prevents CPython from
	# releasing the GIL during procedure calls.
	_libc_name = ctypes.util.find_library("c")
	if _libc_name is None:
	raise RuntimeError("Cannot find libc")
	libc_py = ctypes.PyDLL(_libc_name)
	...
	libc_py.usleep(...)

	<!doctype html>
	<script type="application/javascript">
	const s = `
	application/mp4
	application/mp4; codecs=bogus
	application/octet-stream
	application/octet-stream; codecs='avc1.42E01E, mp4a.40.2'
	application/octet-stream; codecs='mp4a.40.2'
	application/octet-stream; codecs='theora, vorbis'
	application/octet-stream; codecs='vorbis'

	# This is a hack so that French translation falls back to English translation,
	# not German translation (which is the default locale and the original
	# strings).
	from django.utils.translation import trans_real


	class MyDjangoTranslation(trans_real.DjangoTranslation):
	def _add_fallback(self, localedirs=None):
	if self._DjangoTranslation__language[:2] in {'de', 'en'}:
	return super()._add_fallback(localedirs)

	"""Our convenience Celery Task wrapper that allows us to conveniently pass
	model instances as Task arguments.

	It "serializes" model instances to IDs and "deserializes" these IDs to model
	instances upon task execution.

	Serialized representation of a model instance is (sentinel, app_name, model_name, pk).
	"""
	import celery
	from django.apps import apps