The first step is to create a network using the CLI. This network will allow us to attach multiple containers which will be able to discover each other.

In this example, we're going to start by creating a backend-network. All containers attached to our backend will be on this network.

Task: Create Network

To start with we create the network with our predefined name. docker network create backend-network

Task: Connect To Network

When we launch new containers, we can use the --net attribute to assign which network they should be connected to docker run -d --name=redis --net=backend-network redis

In the next step we'll explore the state of the network.

Docker supports multiple networks and containers being attached to more than one network at a time.

For example, let's create a separate network with a Node.js application that communicates with our existing Redis instance.

Task

The first task is to create a new network in the same way.

docker network create frontend-network`

When using the connect command it is possible to attach existing containers to the network.

docker network connect frontend-network redis

When we launch the web server, given it's attached to the same network it will be able to communicate with our Redis instance.

docker run -d -p 3000:3000 --net=frontend-network katacoda/redis-node-docker-example

Protip

You can verify that the containers are communicating by selecting Port 3000 located next to terminal and clicking reload icon. This dashboard is connected to Port 3000 of the docker host.

With our networks created, we can use the CLI to explore the details.

The following command will list all the networks on our host. docker network ls

We can then explore the network to see which containers are attached and their IP addresses. docker network inspect frontend-network

The following command disconnects the redis container from the frontend-network. docker network disconnect frontend-network redis

The goal of this step is to start a nginx container which binds directly to port 80 on the Docker host. From a networking point of view, this is the same level of isolation as if the nginx process were running directly on the Docker host and not in a container. However, in all other ways, such as storage, process namespace, and user namespace, the nginx process is isolated from the host.

Open a terminal window. You can list current networks by running docker network ls

The default bridge network is listed, along with host and none. The latter two are not fully-fledged networks, but are used to start a container connected directly to the Docker daemon host’s networking stack, or to start a container with no network devices. This tutorial will connect two containers to the bridge network.

Task

Create and start the container as a detached process. The --rm option means to remove the container once it exits/stops. The -d flag means to start the container detached (in the background). docker run --rm -d --network host --name my_nginx nginx

Protip

You can verify that the container is bound to PORT 80 by running curl docker:80

The overlay network driver creates a distributed network among multiple Docker daemon hosts. This network sits on top of (overlays) the host-specific networks, allowing containers connected to it (including swarm service containers) to communicate securely. Docker transparently handles routing of each packet to and from the correct Docker daemon host and the correct destination container.

Task

You can create user-defined overlay networks using docker network create, in the same way that you can create user-defined bridge networks.

To create an overlay network for use with swarm services, use a command like the following: docker network create -d overlay my-overlay

To create an overlay network which can be used by swarm services or standalone containers to communicate with other standalone containers running on other Docker daemons, add the --attachable flag: docker network create -d overlay --attachable my-attachable-overlay

In the next step, we will talk about default overlay network called ingress when docker host initializes a swarm or joins an existing swarm.

When you initialize a swarm or join a Docker host to an existing swarm, two new networks are created on that Docker host:

• An overlay network called ingress, which handles control and data traffic related to swarm services. When you create a swarm service and do not connect it to a user-defined overlay network, it connects to the ingress network by default.
• A bridge network called docker_gwbridge, which connects the individual Docker daemon to the other daemons participating in the swarm.

Services or containers can be connected to more than one network at a time. Services or containers can only communicate across networks they are each connected to.

Task : Publish a port for a service

Use the --publish flag to publish a port when you create a service. target is used to specify the port inside the container, and published is used to specify the port to bind on the routing mesh.

To create an overlay network for use with swarm services, use a command like the following: docker service create \ --name my-web \ --publish published=8080,target=80 \ --replicas 2 \ nginx

When you access port 8080 on any node, Docker routes your request to an active container. On the swarm nodes themselves, port 8080 may not actually be bound, but the routing mesh knows how to route the traffic and prevents any port conflicts from happening.

You can use docker service inspect to view the service’s published port. For instance: docker service inspect --format="{{json .Endpoint.Spec.Ports}}" my-web

The output shows the (labeled TargetPort) from the containers and the (labeled PublishedPort) where nodes listen for requests for the service

Task : Add port for a service

You can publish a port for an existing service using the following command:

To create an overlay network for use with swarm services, use a command like the following: docker service update \ --publish-add published=8081,target=80 \ my-web

Now, when you access port 8080 or 8081 on any node, Docker routes your request to an active container. You can also verify that the application is running by selecting Port 8080 and Port 8081 located next to terminal icon.