To run a Scala application in Docker, we need to containerize it by setting up a Dockerfile that installs Scala and runs your Scala application. Below is an example to help you get started with Dockerizing a simple Scala application.

Steps to Dockerize a Scala Application

In this example, we will create a basic Scala application, set up a Dockerfile for it, and run the application inside a Docker container.

1. Prepare Your Scala Application

Start by writing a simple Scala script. Let's create a file named Hello.scala.

Hello.scala:

object Hello extends App {  println("Hello from Docker and Scala!")}

This is a very basic Scala script that simply prints a message.

2. Create a Dockerfile

Now, we’ll create a Dockerfile that will install the necessary Scala environment (along with Java) and run the Scala application inside the container.

Example Dockerfile:

# Step 1: Use an official OpenJDK image as the base (Java is needed to run Scala)FROM openjdk:11-jre-slim# Step 2: Set the working directory inside the containerWORKDIR /usr/src/app# Step 3: Install Scala and other dependenciesRUN apt-get update && apt-get install -y wget \    && wget https://downloads.lightbend.com/scala/2.13.8/scala-2.13.8.deb \    && dpkg -i scala-2.13.8.deb \    && rm scala-2.13.8.deb \    && apt-get clean# Step 4: Copy the Scala file into the containerCOPY Hello.scala .# Step 5: Compile the Scala file using the Scala compilerRUN scalac Hello.scala# Step 6: Run the Scala application when the container startsCMD ["scala", "Hello"]

Explanation of the Dockerfile:

1. FROM openjdk:11-jre-slim: We use an OpenJDK image with Java 11 as the base. Scala requires Java to run, so we need this base image.
2. WORKDIR /usr/src/app: This sets the working directory inside the container to /usr/src/app. All subsequent commands (like COPY, RUN, and CMD) will execute in this directory.
3. RUN apt-get update && apt-get install -y wget ...: This installs Scala by downloading the .deb package for Scala and installing it on the container.
4. COPY Hello.scala .: This copies your Hello.scala file from your local machine into the container’s /usr/src/app directory.
5. RUN scalac Hello.scala: This compiles the Hello.scala file using the Scala compiler (scalac).
6. CMD ["scala", "Hello"]: This runs the compiled Scala application (Hello) when the container starts.

3. Build the Docker Image

Now that you have the Dockerfile and the Scala application, it's time to build the Docker image.

1. Open a terminal (or command prompt).
2. Navigate to the directory where your Dockerfile and Hello.scala file are located.
3. Run the following command to build the Docker image:

docker build -t scala-docker-app .

This will build the Docker image with the tag scala-docker-app.

4. Run the Docker Container

Once the image is built, you can run the container and execute your Scala application. Use the following command:

docker run scala-docker-app

You should see the following output:

Hello from Docker and Scala!

This confirms that the Scala application is running inside the Docker container.

5. (Optional) Share the Image on Docker Hub

If you want to share your Docker image, you can push it to Docker Hub.

1. Log in to Docker Hub:

   docker login
   

   Enter your Docker Hub username and password.

2. Tag the Image:

   Tag the image for Docker Hub. Replace yourusername with your Docker Hub username:

   docker tag scala-docker-app yourusername/scala-docker-app
   

3. Push the Image to Docker Hub:

   Push the tagged image to Docker Hub:

   docker push yourusername/scala-docker-app
   

   Now, your image will be available on Docker Hub for others to pull and run.

6. Cleanup (Optional)

After you're done testing, you can stop and remove the container and image if no longer needed.

• List running containers:

  docker ps
  

• Stop and remove the container:

  docker stop <container_id>docker rm <container_id>
  

• Remove the Docker image:

  docker rmi scala-docker-app
  

Conclusion

You have now successfully containerized a simple Scala application using Docker! By following the steps above, you can run your Scala applications inside Docker containers, making them portable and easy to deploy across different environments.