Docker has been around for a couple of years already, it is a hot open source project that allows you to deploy your applications in containers adding a layer of abstraction. This Docker adaption is growing, and it is growing fast. If you want to learn more about what Docker is and what the benefits of it are, you can check these following resources.
In this post we will use the simple Tutorial application shared in the past with many of you. If you would like to go over the Node.js app I will recommend doing so since this will give you a good base to get started with Autodesk Forge platform. The app lets you authenticate, create buckets, upload files, translate files, use the Forge viewer to visualize the recently translated files. You can find the Tutorial Make sure you pick the Node.js server option since this post will be dedicated to Node.js in Docker.
Once we are ready with our Forge Node.js application we will start with the process of dockerizing our app. The goal of this example is to show you how to get a Node.js application into a Docker container. The guide is intended for development, and not for a production deployment.
Here are a few names used on this tutorial (from Docker Glossary):
- Docker image: An Image is an ordered collection of root filesystem changes and the corresponding execution parameters for use within a container runtime. An image typically contains a union of layered filesystems stacked on top of each other. An image does not have state and it never changes. Docker images are the basis of containers.
- Docker container: A Docker container consists of: a docker image, an execution environment, a standard set of instructions. The concept is borrowed from Shipping Containers, which define a standard to ship goods globally. Docker defines a standard to ship software. A container is a runtime instance of a docker image.
The guide also assumes you have:
- Nodejs app (e.g. you can use this tutorial code)
Time to complete: 2 hours
The Dockerfile defines the container and actions to be performed on initialization.
Note: A Dockerfile is a text document that contains all the commands a user could call on the command line to assemble an image. Using docker build users can create an automated build that executes several command-line instructions in succession. This page describes the commands you can use in a Dockerfile .
Assuming you have a project similar to the tutorial, at the root of your project, create an empty file called Dockerfile, from your terminal you can type the following:
Open the recently created Dockerfile in your favorite text editor
The first thing we need to do is define from what image we want to build from. For the base image, we will use the latest LTS version node:carbon this is the BUILD part.
Note: If you want to find out more about what code name “carbon” is you can read more about it Be aware that specifying the version of Node is also another option.
FROM node:carbon AS build
Next, we will create an app directory and set its location to it.
Now, we will copy the package.json and package-lock.json into the container work directory.
ADD package.json . ADD package-lock.json .
We will install the app and copy the app code to the container image.
RUN npm install ADD . .
We are now done with the BUILD part and we will start cleaning up the dockerization (is that even a word??) process.
We will copy the app from the BUILD stage
COPY --from=build /usr/src/app .
We will create ENV variables since our Node.js app uses them in the config.js file. The value of our keys will be passed at the time of run time of our container.
ENV FORGE_CLIENT_ID=default ENV FORGE_CLIENT_SECRET=default
We will use the same port as our original application, but we still need to define it.
Last but not least, define the command to run your app using CMD which defines your runtime. Here we will use the basic npm start which will run node server.js to start your server:
CMD [ "npm", "start" ]
Your Dockerfile should now look like this.
# start with image that has Node.js, this is BUILD part FROM node:carbon AS build # Create app directory, set this as work directory WORKDIR /usr/src/app # copy package.json AND package-lock.json into container work dir ADD package.json . ADD package-lock.json . # install the app and copy app code to container image RUN npm install ADD . . # clean the stuff up, this is part 2 FROM node:carbon # Copy app from BUILD stage COPY --from=build /usr/src/app . # use the value to set the ENV var default ENV FORGE_CLIENT_ID=default # use the value to set the ENV var default ENV FORGE_CLIENT_SECRET=default # define default port EXPOSE 3000 # run container CMD [ "npm", "start" ]
Create a .dockerignore file in the same directory as your Dockerfile with following content:
Tip: if you are using git, just duplicate your .gitignore and add .git folder (usually hidden). This will prevent your local modules and debug logs from being copied onto your Docker image and possibly overwriting modules installed within your image.
Go to the directory that has your
Dockerfile and run the following command to build the Docker image. The
-t flag lets you tag your image so it's easier to find later using the
docker images command:
# build image docker build -t autodesk-forge-docker .
At the terminal, at the first time, it will start downloading the node:carbon. Then you should see steps 1 through 11, similar to the following:
Sending build context to Docker daemon 10.92MB Step 1/11 : FROM node:carbon AS build ---> ed145ef978c4 Step 2/11 : WORKDIR /usr/src/app ---> Using cache ---> 4b0cf8d43623 Step 3/11 : ADD package*.json . ---> Using cache ---> 8c894ea8ae9b Step 4/11 : RUN npm install ---> Using cache ---> 574c922e2ff5 Step 5/11 : ADD . . ---> 8d416dce229f Step 6/11 : FROM node:carbon ---> ed145ef978c4 Step 7/11 : COPY --from=build /usr/src/app . ---> 0008a3a2fac8 Step 8/11 : ENV FORGE_CLIENT_ID=default ---> Running in 5efff0d539c2 Removing intermediate container 5efff0d539c2 ---> 08ee432e37ed Step 9/11 : ENV FORGE_CLIENT_SECRET=default ---> Running in 53e15aed2634 Removing intermediate container 53e15aed2634 ---> 8dc4f8f03fab Step 10/11 : EXPOSE 3000 ---> Running in 8afb5e9034cb Removing intermediate container 8afb5e9034cb ---> bcf445ff2897 Step 11/11 : CMD [ "npm", "start" ] ---> Running in fc5d20dc2a84 Removing intermediate container fc5d20dc2a84 ---> 158b068617a5 Successfully built 158b068617a5 Successfully tagged autodesk-forge-docker:latest
Now, your Docker Image has been created. You can check your recently created image ID by typing
Running your image with
-d runs the container in detached mode, leaving the container running in the background. We will also pass in the values for our Forge Client ID & Secret ENV’s.
docker run -e FORGE_CLIENT_ID='YOURCLIENTID' -e FORGE_CLIENT_SECRET='YOURCLIENTSECRET' -d --name autodesk-forge-docker -p 3000:3000 autodesk-forge-docker
This will output your image Id. Congrats you have now dockerized your Forge Node.js application and it is running on port 3000.
You can also start your container by specifying a port mapping:
docker run -p 3001:3000 <image-name>.
Then is the port 3000 of your container mapped to the port 3001 of your local machine. So that you can access it through localhost:3001. See also the reference for more details.
In order to get your container ID, you can obtain it with the following command.
Followed by printing the logs of that container.
docker logs <container id>
> email@example.com start / > node start.js Starting at Wed Aug 15 2018 20:02:05 GMT+0000 (UTC) Server listening on port 3000
Next time I will show you how to scale this to a Production environment using AWS ECR (Amazon Elastic Container Registry). Thanks for reading.