Navigating Classic Assets and Smart Contract Tokens on Soroban
Fabricius Zatti | Feb 28, 2024
Onboarding new developers in a project is always nice: they bring new ideas, different expertises and outside-the box thoughts. They tend to tackle problems and create solutions in a creative way, adding even more enthusiasm to the team. But before getting down to code, they need to set up their own development environment, which can easily become a headache.
Installing a local database, compiling the right program language version and solving library dependencies – possibly across different operating systems – are a few tasks inside this challenge.
Today I’ll introduce to you Docker and Compose – a container platform and its simple configuration tool – to help your team get up and running as fast as possible.
Software development has quickly evolved in the past years, but it still hard to create a unique setup that works on development, staging and production. Currently there are three main ways of doing it:
If you need more information on the process evolution, be sure to read this post, it is an awesome guide from understanding better the concept of virtual machines and containers. Also Docker Youtube’s channel has great content about its entire stack!
All options have their benefits and downsides, but the software world is shifting towards a containerized approach. Why? Docker!
Quoting the documentation:
Docker containers wrap a piece of software in a complete filesystem that contains everything needed to run: code, runtime, system tools, system libraries – anything that can be installed on a server. This guarantees that the software will always run the same, regardless of its environment.
To provide its magic, Docker made Linux kernel containerization simple and accessible for everyone, providing an API to resources like cgroups and namespaces. It also leverages its own characteristics, like images, registries, onion filesystem, plain text configuration file and so on. I could write about each one, but I would just be duplicating this amazing article from the official documentation. Be sure to check that out 😀
For the developer, this means that now it is possible to have application isolation, little overhead and the same setup as their colleagues quickly and easy.
To speed up the process even more, we will be using Compose: a tool for defining and running multi-container Docker applications. It uses a single file to declare your entire stack and just one command to bring it up.
I assume you have Docker already installed on your machine, but if you don’t, the installation process is well-documented here.
The file below is called
docker-compose.yml. It is responsible for defining your containers’ information like storage, networking and so on and usually lives in the project’s root folder. I made some comments to describe the most important lines, yet you can find useful information at the official documentation.
# Containers are described as services
# Service name
# Docker image to be pulled from the registry
# Named volume mapping to store database information
# Instead of using an image, we build our container with a Dockerfile inside the ./web directory
# Command to start the Django webserver
command: bash -c "sleep 10 && python manage.py runserver 0.0.0.0:8000"
# Mapping of Django app code (you should point to yours)
# Port to listen on the localhost
# Database's volume definition
After creating it, you simply need to run
docker-compose up to get your environment up and running!
With this simple file, you are able to run a Django + PostgreSQL project within Docker containers! You may have to change some environment variables or make minor changes to get it working. You can read about a full configuration of a Django project, with PostgreSQL and NGINX as a reverse proxy at my personal blog.
As the title says, you can use this approach to quickly and easily scale your engineering team. By having Docker Compose and a
docker-compose.yml in your project, you enable anyone to start working with your team with a few commands. Also, you create a normalized development environment for everyone, which can even be run in production – but this is an adventure for my next post. Stay tuned!
Believes in love-driven development. Linux guy and Python addicted. Enthusiast in DevOps culture and open-source projects.