Docker to Docker Networking Between TCP Client and Server
This article presents a step-by-step instructions on how to create a TCP client and server for IoT applications using Docker containers and networking.
By
·
·
Tutorial
Likes
(0)
Likes
There are no likes...yet! 👀
Be the first to like this post!
It looks like you're not logged in.
Sign in to see who liked this post!
Comment
Save
9.4K Views
Join the DZone community and get the full member experience.
Join For Free
A TCP-based client and server are a frequently needed setup in IoT-based applications.
Presented in this article are:
- A method to create a Java-based client and server to send and receive binary data
- The client and server, each run inside a Docker container and communicating through Docker networking.
You may also enjoy: Understanding Docker Networking
Create a TCPClient.java as per the code provided below
Java
x
123
1
import java.net.*;
2
import java.io.*;
3
import java.security.SecureRandom;
4
import java.nio.charset.Charset;
5
6
public class TCPClient
7
{
8
// initialize socket and input output streams
9
private Socket socket = null;
10
private DataInputStream input = null;
11
private DataOutputStream out = null;
12
13
private static final String CHAR_LOWER = "abcdefghijklmnopqrstuvwxyz";
14
private static final String CHAR_UPPER = CHAR_LOWER.toUpperCase();
15
private static final String NUMBER = "0123456789";
16
17
private static final String DATA_FOR_RANDOM_STRING = CHAR_LOWER + CHAR_UPPER + NUMBER;
18
private static SecureRandom random = new SecureRandom();
19
20
// constructor to put ip address and port
21
public TCPClient(String address, int port)
22
{
23
24
25
26
// establish a connection
27
try
28
{
29
socket = new Socket(address, port);
30
System.out.println("Connected");
31
32
33
34
}
35
catch(UnknownHostException u)
36
{
37
System.out.println(u);
38
}
39
catch(IOException i)
40
{
41
System.out.println(i);
42
}
43
44
// string to read message from input
45
String line = "";
46
int linecount = 0;
47
48
// keep reading until "Over" is input
49
while (linecount++ != 300)
50
{
51
52
53
try{
54
String name = generateRandomString(8);
55
56
InputStream is = new ByteArrayInputStream(name.getBytes(Charset.forName("UTF-8")));
57
// takes input from terminal
58
input = new DataInputStream(is);
59
60
// sends output to the socket
61
out = new DataOutputStream(socket.getOutputStream());
62
}
63
catch(UnknownHostException u)
64
{
65
System.out.println(u);
66
}
67
catch(IOException i)
68
{
69
System.out.println(i);
70
}
71
72
try
73
{
74
line = input.readLine();
75
out.writeUTF(line);
76
}
77
catch(IOException i)
78
{
79
System.out.println(i);
80
}
81
}
82
83
// close the connection
84
try
85
{
86
input.close();
87
out.close();
88
socket.close();
89
}
90
catch(IOException i)
91
{
92
System.out.println(i);
93
}
94
}
95
96
public static String generateRandomString(int length) {
97
if (length < 1) throw new IllegalArgumentException();
98
99
StringBuilder sb = new StringBuilder(length);
100
for (int i = 0; i < length; i++) {
101
102
// 0-62 (exclusive), random returns 0-61
103
int rndCharAt = random.nextInt(DATA_FOR_RANDOM_STRING.length());
104
char rndChar = DATA_FOR_RANDOM_STRING.charAt(rndCharAt);
105
106
// debug
107
System.out.format("%d\t:\t%c%n", rndCharAt, rndChar);
108
109
sb.append(rndChar);
110
111
}
112
113
return sb.toString();
114
115
}
116
public static void main(String args[])
117
{
118
TCPClient client = new TCPClient("server", 5678);
119
}
120
}
121
Create a manifest file for the TCPClient as is shown below:
Java
xxxxxxxxxx
1
1
Manifest-Version: 1.0
2
Created-By: Me
3
Main-Class: TCPClient
Create a Dockerfile for TCPClient as below:
Dockerfile
xxxxxxxxxx
1
1
FROM java:8
2
WORKDIR /
3
ADD TCPClient.jar TCPClient.jar
4
EXPOSE 5678
5
CMD java -jar TCPClient.jar
Create a TCPServer.java as per the code provided below:
Java
xxxxxxxxxx
1
74
1
import java.net.*;
2
import java.io.*;
3
4
public class TCPServer
5
{
6
//initialize socket and input stream
7
private Socket socket = null;
8
private ServerSocket server = null;
9
private DataInputStream in = null;
10
private File file;
11
private FileWriter fileWriter;
12
13
// constructor with port
14
public TCPServer(int port)
15
{
16
// starts server and waits for a connection
17
try
18
{
19
server = new ServerSocket(port);
20
System.out.println("Server started");
21
22
System.out.println("Waiting for a client ...");
23
24
socket = server.accept();
25
System.out.println("Client accepted");
26
27
// takes input from the client socket
28
in = new DataInputStream(
29
new BufferedInputStream(socket.getInputStream()));
30
31
String line = "";
32
int linecount = 0;
33
34
file = new File("outfile.txt");
35
fileWriter = new FileWriter(file);
36
37
38
// reads message from client until "Over" is sent
39
while (linecount++ != 300)
40
{
41
try
42
{
43
line = in.readUTF();
44
System.out.println(line);
45
fileWriter.write(line);
46
47
48
49
}
50
catch(IOException i)
51
{
52
System.out.println(i);
53
}
54
}
55
System.out.println("Closing connection");
56
fileWriter.flush();
57
fileWriter.close();
58
// close connection
59
socket.close();
60
in.close();
61
}
62
catch(IOException i)
63
{
64
System.out.println(i);
65
}
66
}
67
68
public static void main(String args[])
69
{
70
TCPServer server = new TCPServer(5678);
71
}
72
}
Create a manifest file for TCPServer as below:
Shell
xxxxxxxxxx
1
1
Manifest-Version: 1.0
2
Created-By: Me
3
Main-Class: TCPServer
Create a Dockerfile for TCPServer as below
Shell
xxxxxxxxxx
1
1
FROM java:8
2
WORKDIR /
3
ADD TCPServer.jar TCPServer.jar
4
EXPOSE 5678
5
CMD java -jar TCPServer.jar
The directory structure should be as displayed as shown below:
Run the following commands at the unix prompt:
Shell
xxxxxxxxxx
1
41
1
javac TCPServer.java
2
3
javac TCPClient.java
4
5
6
7
jar cfm TCPServer.jar manifest.txt TCPServer.class
8
9
jar cfm TCPClient.jar manifest.txt TCPClient.class
10
11
12
13
docker build -t tcpserver .
14
15
docker build -t tcpclient .
16
17
18
19
docker images (to list the docker images)
20
21
docker tag 00c5f2d27133 docker.io/<your account name>/<repo name>:tcpserver
22
23
docker push docker.io/<your account name>/<repo name>:tcpserver
24
25
26
27
docker images (to list the docker images)
28
29
docker tag 00c5f2d27133 docker.io/<your account name>/<repo name>:tcpclient
30
31
docker push docker.io/<your account name>/<repo name>:tcpclient
32
33
34
35
docker pull docker.io/<your account name>/<repo name>:tcpserver
36
37
docker pull docker.io/<your account name>/<repo name>:tcpclient
38
39
docker run <your account name>/<repo name>:tcpserver
40
41
docker run <your account name>/<repo name>:tcpclient
Create the network:
Shell
xxxxxxxxxx
1
1
sudo docker network create client_server_network
Run the server:
Shell
xxxxxxxxxx
1
1
docker run --network-alias server --network client_server_network -it <your account name>/<repo name>:tcpserver
Run the client:
Shell
xxxxxxxxxx
1
1
docker run --network client_server_network -it <your account name>/<repo name>:tcpclient
You should see the client output as shown below:
And the server output should be as shown below:
Docker (software)
Transmission Control Protocol
Opinions expressed by DZone contributors are their own.
Comments