To run an application inside of a container you first need to build the Docker Image. The Docker Image should contain everything required to start your application, including dependencies and configuration.

Docker Images are created based on a Dockerfile. A Dockerfile is a list of instructions that define how to build and start your application. During the build phase, these instructions are executed. The Dockerfile allows image creation to be automated, repeatable and consistent.

The first part of a Dockerfile is to define the base image. Docker has an embrace and extends approach. Your Dockerfile should only describe the steps required for your application. All runtime dependencies, such as .NET Core, should be in the base image. The use of base images improves the build time and allows the image to be shared across multiple projects.

Task

Start writing the Dockerfile by defining the base image in the editor.

FROM ocelotuproar/docker-alpine-fsharp:4.0

The next stage of the Dockerfile is to define the dependencies the application requires to start.

The RUN instruction executes the command, similar to launching it from the bash command line. The WORKDIR instruction defines the working directory where commands should be executed from. The COPY instruction copies files and directories from the build directory into the container image. This is used to copy the source code into the image, allowing the build to take place inside the image itself.

All the commands are run in order. Under the covers, Docker is starting the container, running the commands, and then saving the image for the next command.

Task

Continue creating the Dockerfile by defining the directory and how to download and configure the dependencies.

RUN         mkdir -p /src
WORKDIR     /src

COPY        paket.bootstrapper.exe /src
RUN         mono paket.bootstrapper.exe

COPY        paket.dependencies /src
RUN         mono paket.exe install

Once the Dockerfile has the required dependencies it now needs to define how to build and run your application.

The EXPOSE instruction is a description about what ports the application is listening on. This helps describe how the application should be started and run in production. This can be considered part of the documentation, or metadata, about the image and application.

The CMD instruction defines the default command to run when the Docker Container is started. This can be overridden when starting the container.

Task

Continue creating the Dockerfile by defining the directory and how to download and configure the dependencies.

COPY . /src

EXPOSE      8083
CMD         ["fsharpi", "server.fsx"]

With the Dockerfile created, you can use the Docker CLI to build the image.

Task

Create a Docker Image by building and executing the Dockerfile using the Docker CLI.

When creating the image we also define a friendly name and tag. The name should refer to the application, in this case aspnet. The tag is a string and commonly used as a version number, in this case it's v0.1.

docker build -t fsharp-app:v0.1 .

You can view the Docker Images on your host using docker images | head -n2

Try breaking the build and see what happens.

Once the Docker Image has been built you can be launch it in the same way as other Docker Images.

Task

Start the newly build image and expose the port 8083 so the web application can be accessed.

docker run -d \ -t -p 8083:8083 \ --name app \ fsharp-app:v0.1

Once the container and process has started you can use curl to access the running application.

You can view the application logs using docker logs app

curl http://docker:8083

You've now successfully built an F# application as a Docker Image.