{"id":36,"date":"2017-02-09T22:37:00","date_gmt":"2017-02-09T22:37:00","guid":{"rendered":""},"modified":"2019-03-12T20:10:16","modified_gmt":"2019-03-12T20:10:16","slug":"putting-tomcat-into-a-container","status":"publish","type":"post","link":"https:\/\/ntlx.org\/de\/2017\/02\/putting-tomcat-into-a-container.html","title":{"rendered":"Putting tomcat into a container"},"content":{"rendered":"

As soon as you get in touch with software there is no chance to get around one topic these days: Microservices. And wherever you hear this term there is always a second one around the corner: Docker. I myself have only little experience in productively using docker, and this is mostly restricted to the convenience of packaging stuff and installing it somewhere else via a central repository. But already this is quite cool, so why not try to go further and create a small Java service in a docker container if setting up things is so easy with docker. The goal of this post is to document how I achieved a first response of the service – setting up a Java microservice with docker should be almost no work, right? As I haven’t had much contact with tomcat and maven, I learned all this (not much in the end but it took some time) the hard way – fighting all the way through old forum posts, maven repositories, eclipse UIs, tomcat books and documentations. Please let me know if you see any potential improvements.<\/p>\n

Setting things up<\/h2>\n

Here we go. First of all I created a docker-compose file that shows how my microservice-powered project will look like:<\/p>\n

<\/p>\n

\n\n\n\n
\n
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26<\/pre>\n<\/td>\n
\n
proxy:
    image: nginx
    links:
        - frontend
        - backend
    volumes:
        - .\/proxy\/nginx.conf:\/etc\/nginx\/conf.d\/default.conf
    ports:
        - \"80:80\"<\/span>
frontend:
    image: nginx
    volumes:
        - .\/frontend:\/usr\/share\/nginx\/html
backend:
    image: tomcat
    links: 
        - database
    volumes:
        - .\/backend\/tomcat-users.xml:\/usr\/local\/tomcat\/conf\/tomcat-users.xml
database:
    image: mysql
    environment:
        - MYSQL_ROOT_PASSWORD=topsecret
        - MYSQL_DATABASE=mydb
        - MYSQL_USER=mydbuser
        - MYSQL_PASSWORD=
<\/pre>\n<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n<\/div>\n
I know container-links are not the most modern way to go in the docker universe, but for the ease of use and to show how things are tangled together, I still use them for this small project. As you can see, we have four different containers. One for the frontend, containing the great UI of our application. A second one containing the database with all the data the application will need to run. Don’t worry, I won’t bother you with boring database setup in this blog post. It’s only about the third thing: the tomcat container. For this container we add a link to the database, of course, and we mount a local file to override the user configuration of the tomcat.
This is needed to be able to show the manager application and to deploy remotely to the tomcat server. Here is the config file as I created it. (I copied it out of the container and adjusted it, maybe you should do the same to make sure it’s compatible with your version of tomcat. And, for productive usage, of course you should use a password for the admin user. But configuring maven is more complicated then, so for now it’s ok without for me.)<\/p>\n
<\/p>\n
\n\n\n\n
\n
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48<\/pre>\n<\/td>\n
\n
<?xml version='1.0' encoding='utf-8'?><\/span>
<!--<\/span>
  Licensed to the Apache Software Foundation (ASF) under one or more<\/span>
  contributor license agreements.  See the NOTICE file distributed with<\/span>
  this work for additional information regarding copyright ownership.<\/span>
  The ASF licenses this file to You under the Apache License, Version 2.0<\/span>
  (the \"License\"); you may not use this file except in compliance with<\/span>
  the License.  You may obtain a copy of the License at<\/span>

      http:\/\/www.apache.org\/licenses\/LICENSE-2.0<\/span>

  Unless required by applicable law or agreed to in writing, software<\/span>
  distributed under the License is distributed on an \"AS IS\" BASIS,<\/span>
  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.<\/span>
  See the License for the specific language governing permissions and<\/span>
  limitations under the License.<\/span>
--><\/span>
<tomcat-users<\/span> xmlns=<\/span>\"http:\/\/tomcat.apache.org\/xml\"<\/span>
              xmlns:xsi=<\/span>\"http:\/\/www.w3.org\/2001\/XMLSchema-instance\"<\/span>
              xsi:schemaLocation=<\/span>\"http:\/\/tomcat.apache.org\/xml tomcat-users.xsd\"<\/span>
              version=<\/span>\"1.0\"<\/span>><\/span>
<!--<\/span>
  NOTE:  By default, no user is included in the \"manager-gui\" role required<\/span>
  to operate the \"\/manager\/html\" web application.  If you wish to use this app,<\/span>
  you must define such a user - the username and password are arbitrary. It is<\/span>
  strongly recommended that you do NOT use one of the users in the commented out<\/span>
  section below since they are intended for use with the examples web<\/span>
  application.<\/span>
--><\/span>
<!--<\/span>
  NOTE:  The sample user and role entries below are intended for use with the<\/span>
  examples web application. They are wrapped in a comment and thus are ignored<\/span>
  when reading this file. If you wish to configure these users for use with the<\/span>
  examples web application, do not forget to remove the <!.. ..> that surrounds<\/span>
  them. You will also need to set the passwords to something appropriate.<\/span>
--><\/span>
<!--<\/span>
  <role rolename=\"tomcat\"\/><\/span>
  <role rolename=\"role1\"\/><\/span>
  <user username=\"tomcat\" password=\"<must-be-changed>\" roles=\"tomcat\"\/><\/span>
  <user username=\"both\" password=\"<must-be-changed>\" roles=\"tomcat,role1\"\/><\/span>
  <user username=\"role1\" password=\"<must-be-changed>\" roles=\"role1\"\/><\/span>
--><\/span>
<role<\/span> rolename=<\/span>\"manager-script\"<\/span>\/><\/span>
<user<\/span> username=<\/span>\"admin\"<\/span> password=<\/span>\"\"<\/span> roles=<\/span>\"manager-script\"<\/span>\/><\/span>
<role<\/span> rolename=<\/span>\"manager-gui\"<\/span>\/><\/span>
<user<\/span> username=<\/span>\"tomcat\"<\/span> password=<\/span>\"topsecret\"<\/span> roles=<\/span>\"manager-gui\"<\/span>\/><\/span>
<\/tomcat-users><\/span>
<\/pre>\n<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n<\/div>\n
The last container is used to reverse-proxy the requests of the application either to the frontend or to the backend, depending on the URL. In this example, I configured nginx to lead all the requests starting with \/backend (http:\/\/localhost\/backend) or \/manager to the backend container (make sure to set it to the correct port of tomcat, 8080) and all others to the frontend container. So we need to make sure the servlet we are going to create is available under \/backend, so they can be routed through the reverse proxy correctly.
We run docker-compose up -d as usual and some seconds later the containers are up and running. If you now go to http:\/\/localhost\/backend you should already see tomcat greeting you with a 404 error page. Installing tomcat has never been so easy.<\/p>\n
Deploying to tomcat<\/h2>\n
Next, we want to be able to deploy a servlet to the tomcat running in the docker container. To do this, I decided to use maven to build and deploy the project. To get the initial setup, I ran maven with the following command line:<\/div>\n
mvn archetype:generate -DgroupId=com.ntlx -DartifactId=backend -DarchetypeArtifactId=maven-archetype-webapp <\/span>
After the execution of this command you will find your self in a folder structure, containing all the files and folders you always wondered where they come from, and who knows where to put them:<\/p>\n
.\/pom.xml<\/span><\/div>\n
.\/src<\/span><\/div>\n
.\/src\/main<\/span><\/div>\n
.\/src\/main\/resources<\/span><\/div>\n
.\/src\/main\/webapp<\/span><\/div>\n
.\/src\/main\/webapp\/index.jsp<\/span><\/div>\n
.\/src\/main\/webapp\/WEB-INF<\/span><\/div>\n
.\/src\/main\/webapp\/WEB-INF\/web.xml<\/span>

<\/span>The pom.xml now needs some further adjustments because we want to deploy to a remote tomcat server. Here is the complete file, as it looks for me:<\/span>

<\/span><\/p>\n
\n\n\n\n
\n
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82<\/pre>\n<\/td>\n
\n
<project<\/span> xmlns=<\/span>\"http:\/\/maven.apache.org\/POM\/4.0.0\"<\/span> xmlns:xsi=<\/span>\"http:\/\/www.w3.org\/2001\/XMLSchema-instance\"<\/span>
    xsi:schemaLocation=<\/span>\"http:\/\/maven.apache.org\/POM\/4.0.0 http:\/\/maven.apache.org\/maven-v4_0_0.xsd\"<\/span>><\/span>
    <modelVersion><\/span>4.0.0<\/modelVersion><\/span>
    <groupId><\/span>com.ntlx<\/groupId><\/span>
    <artifactId><\/span>backend<\/artifactId><\/span>
    <packaging><\/span>war<\/packaging><\/span>
    <version><\/span>1.0-SNAPSHOT<\/version><\/span>
    <name><\/span>backend Maven Webapp<\/name><\/span>
    <url><\/span>http:\/\/maven.apache.org<\/url><\/span>
    <dependencies><\/span>
        <dependency><\/span>
            <groupId><\/span>junit<\/groupId><\/span>
            <artifactId><\/span>junit<\/artifactId><\/span>
            <version><\/span>3.8.1<\/version><\/span>
            <scope><\/span>test<\/scope><\/span>
        <\/dependency><\/span>
        <dependency><\/span>
            <groupId><\/span>javax.servlet<\/groupId><\/span>
            <artifactId><\/span>javax.servlet-api<\/artifactId><\/span>
            <version><\/span>3.1.0<\/version><\/span>
   <scope><\/span>provided<\/scope><\/span>
        <\/dependency><\/span>


    <\/dependencies><\/span>
    <build><\/span>
        <finalName><\/span>backend<\/finalName><\/span>
        <plugins><\/span>
            <plugin><\/span>
                <groupId><\/span>org.apache.maven.plugins<\/groupId><\/span>
                <artifactId><\/span>maven-compiler-plugin<\/artifactId><\/span>
                <version><\/span>2.3.2<\/version><\/span>
                <configuration><\/span>
                    <source><\/span>1.6<\/source><\/span>
                    <target><\/span>1.6<\/target><\/span>
                <\/configuration><\/span>
            <\/plugin><\/span>
            <plugin><\/span>
                <groupId><\/span>org.apache.maven.plugins<\/groupId><\/span>
                <artifactId><\/span>maven-war-plugin<\/artifactId><\/span>
                <version><\/span>2.3<\/version><\/span>
                <configuration><\/span>
                    <failOnMissingWebXml><\/span>true<\/failOnMissingWebXml><\/span>
                <\/configuration><\/span>
            <\/plugin><\/span>
            <plugin><\/span>
                <groupId><\/span>org.apache.tomcat.maven<\/groupId><\/span>
                <artifactId><\/span>tomcat7-maven-plugin<\/artifactId><\/span>
                <version><\/span>2.2<\/version><\/span>
                <configuration><\/span>
                    <url><\/span>http:\/\/localhost\/manager\/text<\/url><\/span>
                    <server><\/span>TomcatServer<\/server><\/span>
                    <path><\/span>\/backend<\/path><\/span>
                <\/configuration><\/span>
            <\/plugin><\/span>
            <plugin><\/span>
                <groupId><\/span>org.apache.maven.plugins<\/groupId><\/span>
                <artifactId><\/span>maven-dependency-plugin<\/artifactId><\/span>
                <version><\/span>2.1<\/version><\/span>
                <executions><\/span>
                    <execution><\/span>
                        <phase><\/span>validate<\/phase><\/span>
                        <goals><\/span>
                            <goal><\/span>copy<\/goal><\/span>
                        <\/goals><\/span>
                        <configuration><\/span>
                            <silent><\/span>true<\/silent><\/span>
                            <artifactItems><\/span>
                                <artifactItem><\/span>
                                    <groupId><\/span>javax<\/groupId><\/span>
                                    <artifactId><\/span>javaee-endorsed-api<\/artifactId><\/span>
                                    <version><\/span>6.0<\/version><\/span>
                                    <type><\/span>jar<\/type><\/span>
                                <\/artifactItem><\/span>
                            <\/artifactItems><\/span>
                        <\/configuration><\/span>
                    <\/execution><\/span>
                <\/executions><\/span>
            <\/plugin><\/span>
        <\/plugins><\/span>
    <\/build><\/span>
<\/project><\/span>
<\/pre>\n<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n<\/div>\n
It already contains the plugins needed to deploy a servlet and it contains the information to deploy onto a remote tomcat. In our case the remote tomcat is localhost, port 80 (remember: reverse-proxied to port 8080 in the tomcat container). \/manager\/text is needed to deploy our service. That’s why we also created a reverse-proxy for this URL.<\/div>\n
That’s nearly it. If we now run
mvn tomcat7:deploy<\/span>
it should be able to deploy our web application to the tomcat server. Go to http:\/\/localhost\/backend again to see the hello world page, maven created earlier.<\/span><\/p>\n
Adding a servlet<\/span><\/h2>\n<\/div>\n
To provide our RESTful service in the end, we want to use a servlet. Therefore, we need to create a .java file for our servlet class at the right place: src\/main\/java. Create this folder, add some subfolders for your package like com\/ntlx\/ and add a Java Servlet file there. I myself copied the example from the eclipse wizard for servlet creation:<\/span><\/p>\n
<\/div>\n<\/div>\n
<\/p>\n
\n\n\n\n
\n
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40<\/pre>\n<\/td>\n
\n
import<\/span> java.io.IOException<\/span>;<\/span>

import<\/span> javax.servlet.ServletException<\/span>;<\/span>
import<\/span> javax.servlet.annotation.WebServlet<\/span>;<\/span>
import<\/span> javax.servlet.http.HttpServlet<\/span>;<\/span>
import<\/span> javax.servlet.http.HttpServletRequest<\/span>;<\/span>
import<\/span> javax.servlet.http.HttpServletResponse<\/span>;<\/span>
package<\/span> com.<\/span>ntlx<\/span>;<\/span>

\/**<\/span>
 * Servlet implementation class FirstTest<\/span>
 *\/<\/span>
@WebServlet<\/span>(<\/span>\"\/FirstTest\"<\/span>)<\/span>
public<\/span> class<\/span> FirstTest<\/span> extends<\/span> HttpServlet {<\/span>
 private<\/span> static<\/span> final<\/span> long<\/span> serialVersionUID =<\/span> 1L<\/span>;<\/span>

    \/**<\/span>
     * Default constructor. <\/span>
     *\/<\/span>
    public<\/span> FirstTest<\/span>()<\/span> {<\/span>
        \/\/ TODO Auto-generated constructor stub<\/span>
    }<\/span>

 \/**<\/span>
  * @see HttpServlet#doGet(HttpServletRequest request, HttpServletResponse response)<\/span>
  *\/<\/span>
 protected<\/span> void<\/span> doGet<\/span>(<\/span>HttpServletRequest request,<\/span> HttpServletResponse response)<\/span> throws<\/span> ServletException,<\/span> IOException {<\/span>
  \/\/ TODO Auto-generated method stub<\/span>
  response.<\/span>getWriter<\/span>().<\/span>append<\/span>(<\/span>\"Served at: \"<\/span>).<\/span>append<\/span>(<\/span>request.<\/span>getContextPath<\/span>());<\/span>
 }<\/span>

 \/**<\/span>
  * @see HttpServlet#doPost(HttpServletRequest request, HttpServletResponse response)<\/span>
  *\/<\/span>
 protected<\/span> void<\/span> doPost<\/span>(<\/span>HttpServletRequest request,<\/span> HttpServletResponse response)<\/span> throws<\/span> ServletException,<\/span> IOException {<\/span>
  \/\/ TODO Auto-generated method stub<\/span>
  doGet(<\/span>request,<\/span> response);<\/span>
 }<\/span>

}<\/span>
<\/pre>\n<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n<\/div>\n
As you can see, we set the URL to \/FirstTest. This is the relative address where the servlet will be found. So, after a run of <\/span>
mvn tomcat7:redeploy<\/span><\/p>\n
you should see the response of the servlet at http:\/\/localhost\/backend\/FirstTest<\/span><\/div>\n

<\/span><\/div>\n
That’s it, now we can start developing the service! I think this is quite handy as you can deploy the same tomcat on a different machine, like the productive one instead of your developer notebook, and it will work as before. Of course we have to think of a process to package the servlet with the docker container, but this shouldn’t be too much effort.<\/span><\/div>","protected":false},"excerpt":{"rendered":"As soon as you get in touch with software there is no chance to get around one topic these days: Microservices. And wherever you hear this term there is always a second one around the corner: Docker. I myself have only little experience in productively using docker, and this is mostly restricted to the convenience… Artikel ansehen<\/a>","protected":false},"author":1,"featured_media":0,"comment_status":"open","ping_status":"open","sticky":false,"template":"","format":"standard","meta":{"footnotes":""},"categories":[],"tags":[27,24,5],"_links":{"self":[{"href":"https:\/\/ntlx.org\/de\/wp-json\/wp\/v2\/posts\/36"}],"collection":[{"href":"https:\/\/ntlx.org\/de\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/ntlx.org\/de\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/ntlx.org\/de\/wp-json\/wp\/v2\/users\/1"}],"replies":[{"embeddable":true,"href":"https:\/\/ntlx.org\/de\/wp-json\/wp\/v2\/comments?post=36"}],"version-history":[{"count":1,"href":"https:\/\/ntlx.org\/de\/wp-json\/wp\/v2\/posts\/36\/revisions"}],"predecessor-version":[{"id":72,"href":"https:\/\/ntlx.org\/de\/wp-json\/wp\/v2\/posts\/36\/revisions\/72"}],"wp:attachment":[{"href":"https:\/\/ntlx.org\/de\/wp-json\/wp\/v2\/media?parent=36"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/ntlx.org\/de\/wp-json\/wp\/v2\/categories?post=36"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/ntlx.org\/de\/wp-json\/wp\/v2\/tags?post=36"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}