如何访问Docker容器中的内部服务器？

Question

So I am trying to dockerize a Flask application which does the following:

1. Runs internally a Bokeh Server in the container's 127.0.0.1:5006 address.
2. Runs the Flask application in the address 0.0.0.0:5000 so it is accessible from outside the container.
3. When a connection is made, Flask tries to fetch data from the Bokeh Server (which is instantiated with the container). But when running as a container, it never gets to hit the container's own localhost (not even setting it to --net=host).

The only way I have managed to get it working is creating the Bokeh server in 0.0.0.0 as well and passing the container's host IP (I am on Windows) to the address Flask tries to fetch it from (see url field in autoload_server). But this wouldn't work for other machines, obviously.

Here are the relevant chunks of code:

server = Server({'/datavisualization': bokeh_app}, io_loop=io_loop, address="127.0.0.1",
                 allow_websocket_origin=["*"], host=["*"])

@app.route('/')
def bokeh_server():
    # Fetch Running Bokeh Server
    bokeh_embed = autoload_server(model=None,
                                  app_path="/datavisualization",
                                  url="http://127.0.0.1:5006")

    html = render_template('index.html', bokeh_embed=Markup(bokeh_embed))

    return html

if __name__ == '__main__':
    from tornado.httpserver import HTTPServer
    from tornado.wsgi import WSGIContainer
    from bokeh.util.browser import view
    # Serve the Flask app
    http_server = HTTPServer(WSGIContainer(app))
    http_server.listen(5000, address='0.0.0.0')
    io_loop.add_callback(view, "http://0.0.0.0:5000/")
    io_loop.start()

Maybe someone with more background on Docker could help me understand what is going on here please? I assumed that from the container's perspective anything published on localhost would be visible by other services published from within the same container.

Thanks in advance

Answer 1

I'm going to answer the question from what I suspect is going on based on my comment.

In my very brief review of Bokeh and server_document (from https://docs.bokeh.org/en/latest/docs/user_guide/embed.html#bokeh-applications ), it would appear that this function actually generates some JavaScript. It doesn't actually make a connection to the Bokeh server from Python or Flask itself. The connection comes from the browser.

Given this information, listening on http://127.0.0.1:5006 wouldn't allow the browser to connect. Even with the container running in --net=host mode on Windows or Mac will leave the container listening on the Docker virtual machine network and not the actual host, still causing the connection to fail.

The Bokeh server will need to listen on 0.0.0.0 so that any IP coming through the Docker NAT will be able to connect. In addition, you need to tell your browser how to get to this container. This means using the IP address of the VM or the IP of your computer where the Docker container port is exposed.

In a production setting you would likely run the Flask and Bokeh server ports behind a load balancer or other reverse proxy which could then expose a single IP / DNS name to connect to them. You would then use that DNS name or IP as your url param.

Answer 2

If you were running this setup on a Linux machine, then --net=host would allow your container to communicate with the host's loopback interface; that flag is just specifying that the container should not use its own network namespace, and instead just runs with access to all of the host's network adaptors.

However, --net=host doesn't work the same if you're running Docker in Windows or MacOS -- this is because while the docker client is running on your Windows machine, the containers are actually running on a docker daemon in a separate VM. If you run --net=host and point your Flask server at localhost , you are actually hitting the localhost from the docker VM, not your Windows machine's localhost where Bokeh is running.

Networking can be tricky in Docker when you need to deal with multiple containers talking to each other. The problem you are dealing with is how to discover services in your application. There are a few ways to solve this problem:

The simplest is probably to inject the IP of your Bokeh server into your Flask app as config; typically this is done using environment variables, which can be passed when running the docker container with the -e BOKEH_IP=1.2.3.4 flag. You would configure a different IP in production.

You could also containerize your Bokeh server, and then use something like Docker Compose, Docker Swarm, or Kubernetes to handle communication between your services. Docker Compose works on a single machine, Docker Swarm is good for easily scheduling containers across multiple machines, and Kubernetes is a more complex and full-featured option for orchestrating large numbers of interacting services.