I will write the main points how we are do container-based environments with docker-compose. for each and separate site (both frontend and backend code) a separate repo with 1 docker-compose.yml which defines "nginx", "python", "redis", "node", "postgresql" services as separate containers (plus any other we need) and the codebase is mounted to these containers, we don't build new containers for every deploy. Now, since we use multiple sites on 1 machine and we'd like to run them in parallel at ports 80, 443, we have a separate repo with 1 docker-compose.yml that starts a Traefik reverse proxy witha "traefik" docker network. and each repo's docker-compose is set to connect to that "traefik" docker network, each site has a URL set with Traefik labels. For example we set for a repo that a "python" service URL is https://mysite1.com , then if you open the browser at that URL, Traefik automatically routes to that "python" service. Traefik also does built-in automatic Let's Encrypt SSL certificate generation. More info about that: https://doc.traefik.io/traefik/providers/docker/ for vscode there is a plugin called Dev Containers ( https://marketplace.visualstudio.com/items?itemName=ms-vscode-remote.remote-containers ) these allow to attach to any running container in a new vscode window, and we can run debugger and code autocompletion there, since if you attach to a python container, you have a python environment installed. (Plus we use these also for python: https://marketplace.visualstudio.com/items?itemName=ms-python.python https://marketplace.visualstudio.com/items?itemName=ms-python.vscode-pylance , so we use DebugPy to debug python scripts inside that, we start the debugger at inside the container, and we can attach to it fine) for nodejs the same solution could be used. And I think you don't even need to attach to a node JS container as you can run on your computer commands that should execute inside a container like this: docker compose exec , for example: docker compose exec node npm run dev we start the dev environment with docker compose up -d (first for Traefik repo, and after Traefik runs, then again docker compose up -d for each and every site we need to work on), and stop it with docker compose down. Pretty straightforward and standard. note that docker compose down removes containers and volumes, so if you use a persistent database, then you need to define a volume for the db files, so the db will not be lost after docker compose down. If it is a small/medium site that doesn't need high availability and autoscaling, this Traefik with docker-compose solution also works fine for production. The docker-compose alternatives for creating easier dev environments are Lando or DDEV but there's less documentation about those for Python projects, and they are not suitable for production but they are easier to use than docker compose. For example, they do this Traefik proxy setup by themselves, you can create scriptable commands, so you don't need to write the whole command every time like "docker compose exec python python manage.py runserver 0.0.0.0:80" but with a customly defined "lando runserver" as a simple example. More on reddit.com

basic docker is a very accessible and useful skill just in general More on reddit.com

AWS Lambda recently added support for Docker images with Python, where before you had to zip all your code and dependencies. With this update I wanted to make a full length tutorial to cover everything necessary to be productive.

The playlist is broken into six parts:

1. An introduction to the app that will be built and the various AWS components that will be used

2. Cloning the GitHub repo and doing necessary setup to test the application locally

3. Creating a Docker image of the Python script and running it on AWS Lambda, while also showing how painful it is to do even minor updates

4. Adding CI/CD with GitHub Actions to speed up code updates

5. Adding AWS Cloudwatch to create a cron job that schedules the Lambda function to run on periodic intervals

6. Walking through an AWS Cloudformation yaml template that will create the Lambda function and Cloudwatch rule automatically and covering all the benefits of using a Cloudformation template

This tutorial truly is end-to-end. If you enjoy the content, you can help me a ton by doing any or all of the following:

• supporting me on Patreon

• subscribing to my YouTube channel

• liking and/or commenting on the video

• sharing the video or channel on any platform (reddit, twitter, discord, etc.)

• starring the GitHub repo

• following me on GitHub

Any questions or requests, just leave a comment.

More on reddit.com

Hi, newb wannabe programmer here, sorry for the stupid questions and scenario about to follow. I recently got my mgmt to agree to let me experiment with Julia on my work computer (corporate windows environment). The short term goal is to come up with some analytic tools around the work that we already do. The long term goal is to try to convince senior mgmt to let us rewrite (some of) the company’s heavy computational systems with Julia. I will only have three days of admin access to install what I need to get up and running. I am already planning on installing the Juno IDE, as well as versions 1.1 and 0.7 (to be able to update any packages that are still on 0.6). My question is this: do I need Docker? I’m not sure what it even does exactly. My initial need is small scale — just a write a few scripts for analysis and visualization. My long term goal, which isn’t all that feasible, will require being able to deploy code to production. It seems that’s what Docker would be good for, but I am no where near close to anything production (and may never be). So does it make sense for me to install it? Would I get any benefit out of it even if my purposes remain small scale? More on reddit.com