PyCharm 2019.1 Help

Configure a remote interpreter using Docker Compose

Prerequisites

Make sure that the following prerequisites are met:

  • You have a stable Internet connection.

    To operate with Docker you need the busybox image be available on your machine. Ensure that you have a stable Internet connection, so that PyCharm can download and run busybox:latest. Once you have successfully configured Docker, you can go offline.

  • Docker is installed. You can install Docker on the various platforms, but here we'll use the Windows installation.

    Note that you might want to repeat this tutorial on different platforms; then use Docker installations for macOS and Linux (Ubuntu, other distributions-related instructions are available as well).

  • Before you start working with Docker, make sure that the Docker Integration and Python Docker plugins are enabled. The plugins are bundled with PyCharm and activated by default. If the plugins are not activated, enable them on the Plugins page of the Settings / Preferences Dialog as described in Managing plugins.

Preparing an example

We could have actually repeated the same example as was used for Docker, but for Docker Compose it makes no sense - too simple...

To show a realistic example of a Docker Compose application, we'll use a Django application with a PostgreSQL database running in a separate container. Get the project from GitHub, and open it in PyCharm (File | Open).

For this Django application, we should create two containers: one for a database, and one for the application itself. We'll use the Docker Compose to link the two containers together.

Adding files for Docker and Docker Compose

In the Project tool window, right-click the project root and choose New | File (Alt+Insert), enter the filename (here Dockerfile) and enter the following code:

FROM python:3.6 WORKDIR /app # By copying over requirements first, we make sure that Docker will cache # our installed requirements rather than reinstall them on every build COPY requirements.txt /app/requirements.txt RUN pip install -r requirements.txt # Now copy in our code, and run it COPY . /app EXPOSE 8000 CMD ["python", "manage.py", "runserver", "0.0.0.0:8000"]

Next, repeat the same steps for the docker-compose.yml file and enter the following code:

version: '2' services: web: build: . ports: - "8000:8000" volumes: - .:/app links: - db db: image: "postgres:9.6" ports: - "5432:5432" environment: POSTGRES_PASSWORD: hunter2

Let's look at the docker-compose.yml file. This file defines 2 services: web and db, and links them together.

Configuring Docker

Now that we've prepared our example, let's configure Docker.

To do that, open Settings dialog (Ctrl+Alt+S or click Settings on the main toolbar) and click the Docker page under the Build, Execution, Deployment node. Click Add a docker server to create a Docker server.

Accept the suggested default values:

Docker settings

For macOS, select Docker for Mac to connect to the Docker daemon.

Docker settings

Next, apply changes.

Configuring Docker Compose as a remote interpreter

Let's now define a remote interpreter based on Docker-Compose.

Open the Add Python Interpreter dialog by either way:

  • When you're in the Editor, the most convenient way is to use the Python Interpreter widget in the Status bar. Click the widget and select Add Interpreter ...

  • If you are in the Settings/Preferences dialog (Ctrl+Alt+S), select Project <project name> | Project Interpreter. Click the The Configure project interpreter icon and select Add.

In the dialog that opens, select the Docker Compose option, from the drop-down lists select the Docker server, Docker Compose service (here web), configuration file (here docker-compose.yml)and image name (here python).

Why we've chosen web? This choice is explained by the fact, that after configuring a Docker-Compose-based interpreter, we'll be able to create regular run configurations that will alter the behavior of the container we selected. Therefore, if we want to debug the code in a container, that's the one we should select here. All other containers in the compose file will always be started together with this one, but you won't be able to affect their behavior from PyCharm - they'll always behave as if you started them with the command docker-compose up from the command line.

Next, wait while PyCharm starts your Docker-Compose configuration to scan and index:

Configure remote Python interpreter

Using the Docker tool window

Since we've configured Docker, the Docker tool window button appears at the bottom of PyCharm's main window.

Click this button and see your container running:

Docker window

Configuring database credentials

Modify the DATABASES section of the settings.py file in your Django project to add database configuration details:

DATABASES = { 'default': { 'ENGINE': 'django.db.backends.postgresql', 'NAME': 'postgres', 'USER': 'postgres', 'PASSWORD': 'hunter2', 'HOST': 'db' } }

Running your application under Docker-Compose

First, as we are executing a Django application, we must run a migration.

To do that, choose Tools | Run 'manage.py' task and enter migrate:

manage.py task is running in the Docker

(See Running Tasks of manage.py Utility for details.)

Next, create an ordinary Django server run/debug configuration. To do that, on the main menu choose Run | Edit Configurations...; in the dialog that opens click Add Run/Debug configuration for a Django Server and select Django Server:

Run/Debug configuration for a Django server

The only thing you should pay attention to, is that Host field must be set to 0.0.0.0 - to make sure that we listen to requests coming from outside the Docker container.

Launch this configuration (Run | Run 'RunDjangoApp'):

Docker compose run

To see output in your web browser, go to http://localhost:8000 (in the address bar, change 0.0.0.0 to localhost):

Django application output

Summary

Let's summarize what has been done with the help of PyCharm:

  • We downloaded a Django application from GitHub and opened it.

  • We added specific Docker Compose files to our project.

  • We configured a remote interpreter based on Docker Compose.

  • We ran our Django application in the Docker Compose container.

Last modified: 17 May 2019

See Also

Languages, Frameworks and Technologies:

Reference: