When you run docker commands, it uses this socket to talk to the Docker daemon. Of course, the daemon must be running (and it's often disabled by default), but if your user can't access the socket, it wouldn't be able to communicate with the daemon either. You would first install Docker from the distribution's repository.

Introduction

PyCharm integration with Docker allows you to run your applications in the variously configured development environments deployed in Docker containers.

Prerequisites

Make sure that the following prerequisites are met:

• Docker is installed, as described on the page Docker Docs. 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).

• 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.

• Before you start working with Docker, make sure that the Docker plugin is enabled. The plugin is bundled with PyCharm and is activated by default. If the plugin is not activated, enable it on the Plugins page of the Settings/Preferences dialog Ctrl+Alt+S as described in Manage plugins.

  If you are using Docker for Windows, enable the Expose daemon on tcp://localhost:2375 without TLS option in the General section of your Docker settings.

• Also, for Windows, right-click the Docker whale icon, choose Settings from the context menu, and in the General page select the Expose daemon.. checkbox:

Preparing an example

Create a Python project QuadraticEquation, add the Solver.py file and enter the following code:

Configuring Docker as a remote interpreter

Now that we've prepared our example, let's define a Docker-based remote interpreter.

Ensure that you have downloaded and installed Python on your computer.

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 Overview of the user interface. 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 icon and select Add.

In the dialog that opens, select the Docker option, from the drop-down lists select the Docker server (if the server is missing, click New..), and specify the image name.

Python interpreter path should have the default value:

As a result, in the Settings dialog, you should see something like this:

Click OK to apply changes and close the dialog.

Running your application in a Docker container

In the left gutter, next to the main clause, click the button, and choose Run 'Solver.py' command. You see that your script runs in the Docker container:

As you can see, the prefix in the Run tool window shows the container ID.

Debugging your application in a Docker container

Next, let's debug our application. For that, let's put a breakpoint on the line that calculates d, then click and choose Debug 'Solver' .

As you see in the Console tab of the Debug tool window, the debugger runs also in the Docker container:

But now this container has a different id, and hence - different name. You can see it in the Terminal: type the docker ps command and see the container id and name:

It's important that PyCharm creates a new container, when an application is executed in any way. Whether it's running, debugging, running with coverage, testing - each execution requires a new container!

Docker tool window

But is it possible to see all the containers without the Terminal? PyCharm says - yes. You can use the Docker tab in the Services tool window as the UI for the Docker command-line client.

If you have configured Docker as a remote interpreter, you will see the Services tool window button at the bottom side of the main PyCharm window. Click this button and see the docker containers:

Let's look at this tool window more attentively. What do we see here?

• First, we are connected to a Docker daemon:

• Second, if we open the Run tool window, we'll see that the Docker prefix corresponds to the container ID in the Properties tab of the Docker tool window:

• Third, if we open the Debug tool window, we'll see that the Docker prefix (another one!) corresponds to the another container ID in the Properties tab of the Docker tool window:

• And finally, we see the strange names of the containers - they are human-readable and generated by Docker itself.

Summary

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

• We created a project and added a Python script.

• We configured the remote interpreter.

• We ran and debugged our script in the Docker containers.

• Finally, we launched the Docker tool window and saw all the details visible in the Terminal.

In this episode, after a quick intro to containers and images, we see how easy it is to run and connect to a containerised Nginx server. We then see how to stop, re-start and remove the container.

If you are new to Docker, you may want to know why there is so much hype around it. In the last five years this technology has disrupted the IT industry and the way of deploying software architectures. Docker, and containers technology in general, solves many problems for both developers and sys-admins.

With Docker we can package our application dependencies and binaries in, what is called, docker image, and we can use it across multiple environments without having to manage any dependency.
We run our applications in Docker Containers; they run isolated and they can run different versions of the same application on the same machine (Like two different versions of Nginx or PostgreSQL).

Installation

If you haven’t installed Docker yet, it’s really easy.

MacOs: https://docs.docker.com/v17.12/docker-for-mac/install/
Windows: https://docs.docker.com/v17.12/docker-for-windows/install/
Linux (Ubuntu): https://docs.docker.com/v17.12/install/linux/docker-ce/ubuntu/

Running Nginx

It’s now time to start our container

Inside the container, the Nginx server opens the port 80. Containers are isolated and we can’t connect directly to all the container ports, instead we need to use the -p (a shortcut for --publish) option to publish a specific port.

What this option does is to open the port 8000 in localhost and redirect all the connections to the Nginx server, inside the container, accepting connections on port 80 .

Using a browser, we can now connect to localhost:8000. Nginx answers with its default index page.

Running the container we see on in our terminal the log, the stdout and stderr of the Nginx application.

We can’t do anything more with this server right now, but we have seen how easy it is to start a server with Docker.

ls, stop, start and logs

To stop the container we can ctrl+c or we can use another terminal and use the stop command, but we need at first the container id. We list all the running containers with the ls sub-command.

We see that our container has an id 4e03d2305f41, and a randomly assigned name hungry_shaw. We can use both to refer to it

We stop the container. And we see on the other terminal that the server was killed. We also see that our container is not present anymore in the list of running containers.

Passing the option -a to the we also see the stopped containers.

The status of the the container is Exited (0) 14 seconds ago. We can recover it starting it again

And we see that we can again connect to it on localhost:8000.

After starting the container, the docker command returns immediately without printing any log. To be able to see the log we can use the logs command.

Adding the -f option the command doesn’t return and waits for new log

Remove the container

To remove our container we need at first to stop it. Once stopped we can remove it with the rm sub-command

If we check the list of all containers, running and stopped, we see that our container was completely removed

We can also remove a container while is running, forcing the removal, with the -f option