scala akka

by Miguel Lopez

由Miguel Lopez

如何对Scala和Akka HTTP应用程序进行Docker化-简单的方法 (How to Dockerise a Scala and Akka HTTP Application — the easy way)

Using Docker is a given nowadays. In this tutorial we will how to learn to dockerise our Scala and Akka HTTP applications without even creating a Dockerfile ourselves.

如今已经可以使用Docker。 在本教程中，我们将学习如何在自己甚至不创建Dockerfile的情况下对Scala和Akka HTTP应用程序进行 Docker化。

For the purposes of this tutorial, we assume Docker is already installed on the machine. If it isn’t, please follow the official documentation.

就本教程而言，我们假设Docker已经安装在机器上。 如果不是，请遵循官方文档 。

To automate the creation of the Dockerfile for our project, we will use the sbt-native-packager plugin.

为了自动为我们的项目创建Dockerfile，我们将使用sbt-native-packager插件。

You can use any Scala or Akka HTTP project for this tutorial. We will be using the following repository, feel free to clone it and make sure to checkout the branch 6.5-testing-directives.

您可以在本教程中使用任何Scala或Akka HTTP项目。 我们将使用以下存储库 ，随时克隆它，并确保签出6.5-testing-directives分支。

添加插件 (Adding the plugin)

First, we need to add the plugin to our project in the project/plugins.sbt file. If the file doesn't exist, we need to create it, and then add the following line:

首先，我们需要在project/plugins.sbt文件中将插件添加到我们的项目中。 如果文件不存在，我们需要创建它，然后添加以下行：

addSbtPlugin("com.typesafe.sbt" % "sbt-native-packager" % "1.3.6")

Then we need to enable the plugin in our build.sbt file. Add the following line at the top:

然后，我们需要在build.sbt文件中启用该插件。 在顶部添加以下行：

enablePlugins(JavaAppPackaging)

Enabling this plugin also allows us to create an executable for our application. Run sbt stage in the project's root directory.

启用此插件还允许我们为应用程序创建可执行文件。 在项目的根目录中运行sbt stage 。

Now we can execute our application by running ./target/universal/stage/bin/akkahttp-quickstart. You should see a Success! message. If you send a GET request to localhost:9000/todos you'll get a couple of todos.

现在，我们可以通过运行./target/universal/stage/bin/akkahttp-quickstart来执行我们的应用程序。 您应该会看到Success! 信息。 如果您将GET请求发送到localhost:9000/todos您将获得几个待办事项。

Docker化我们的应用程序 (Dockerising our application)

It’s time to start toying around with Docker.

现在是时候开始研究Docker了。

Let’s start by generating the Dockerfile for our application. Run sbt docker:stage, then run cat target/docker/stage/Dockerfile to see its contents:

让我们从为我们的应用程序生成Dockerfile开始。 运行sbt docker:stage ，然后运行cat target/docker/stage/Dockerfile查看其内容：

FROM openjdk:latestWORKDIR /opt/dockerADD --chown=daemon:daemon opt /optUSER daemonENTRYPOINT ["/opt/docker/bin/akkahttp-quickstart"]CMD []

It’s quite simple. It ends up running a similar binary to the one we generated and ran earlier.

这很简单。 它最终运行与我们生成并运行较早的二进制文件相似的二进制文件。

We can build a Docker image using that Dockerfile manually, but there’s a more convenient way of doing so. Let’s run sbt docker:publishLocal. As its name suggests, it will publish a Docker image of our application to our local registry.

我们可以手动使用该Dockerfile来构建Docker映像，但是有一种更方便的方法。 让我们运行sbt docker:publishLocal. 顾名思义，它将把我们的应用程序的Docker映像发布到我们的本地注册表。

Run docker images and you should see the following entry:

运行docker images ，您应该看到以下条目：

REPOSITORY            TAG     IMAGE ID       CREATED          SIZEakkahttp-quickstart   0.1     d03732dd0854   42 seconds ago   774MB

We can now run our application using Docker.

现在，我们可以使用Docker运行我们的应用程序。

Run docker run akkahttp-quickstart:0.1, you should see the Success! message once again.

运行docker run akkahttp-quickstart:0.1 ，您应该会看到Success! 消息再次。

But this time, if we try to query our application we’ll get an error:

但是这一次，如果我们尝试查询我们的应用程序，将会得到一个错误：

Let’s run docker ps to get some information about our running Docker process (output abbreviated):

让我们运行docker ps以获得一些有关我们正在运行的Docker进程的信息(输出缩写)：

CONTAINER ID     IMAGE                       PORTS            NAMES9746162d4723     akkahttp-quickstart:0.1                      serene_agnesi

As we can see, there are no ports exposed, so there’s no way to communicate with our application.

如我们所见，没有暴露的端口，因此无法与我们的应用程序进行通信。

Applications in Docker run in their network by default. There are multiple ways to allow communication between Docker processes and the host machine. The simplest way is to expose a port.

Docker中的应用程序默认在其网络中运行。 有多种方法可以允许Docker进程与主机之间进行通信。 最简单的方法是公开端口。

Stop the running application, either by hitting Ctrl-C or by running docker stop $CONTAINER_ID.

通过Ctrl-C或运行docker stop $CONTAINER_ID停止正在运行的应用程序。

This time when we run it, we’ll expose the respective port as well:

这次运行它时，我们还将公开相应的端口：

docker run -p 9000:9000 akkahttp-quickstart:0.1

We’re now able to query our dockerised application:

现在，我们可以查询我们的dockerized应用程序：

自定义我们的设置 (Customising our setup)

There are several things that we might want to do with the current setup we have:

对于当前的设置，我们可能需要做几件事：

• What if we want a different image name?
  如果我们想要一个不同的图像名称怎么办？
• What if we want to use a different port?
  如果我们想使用其他端口怎么办？
• Can we have a lighter image?
  我们可以得到一个较浅的图像吗？

Let’s explore these common use cases.

让我们探索这些常见的用例。

更改图像名称 (Changing the image name)

If we look into the plugin’s official documentation, we see that there are a number of options we can change.

如果我们查看插件的官方文档 ，我们会发现可以更改许多选项。

Give it a read and see what else you can customise.

读一读，看看还能自定义什么。

To change the image name we can modify the packageName property in our build.sbt file, add the following line after the scalaVersion property:

要更改映像名称，我们可以在build.sbt文件中修改packageName属性，在scalaVersion属性之后添加以下行：

packageName in Docker := "dockerised-akka-http"

Let’s publish the image again. Run sbt docker:publishLocal. We can check that we have a new image by running docker images:

让我们再次发布图像。 运行sbt docker:publishLocal 。 我们可以通过运行docker images来检查是否有新映像：

REPOSITORY            TAG   IMAGE ID       CREATED          SIZE akkahttp-quickstart   0.1   d03732dd0854   42 minutes ago   774MB dockerised-akka-http  0.1   d03732dd0854   42 minutes ago   774MB

Now we have two images, the original one and the new one. Awesome!

现在我们有两个图像，原始图像和新图像。 太棒了！

更改端口 (Changing the port)

We can’t change the port that our application is listening to without making code changes. The port is hardcoded in our application. Ideally, we would read it from an environment variable and maybe have one as default.

如果不进行代码更改，就无法更改应用程序正在侦听的端口。 该端口在我们的应用程序中进行了硬编码。 理想情况下，我们将从环境变量中读取它，并且可能将其作为默认值。

But that’s okay. Because our application is running in a different network, we can map a different port to the internal 9000 port.

但是没关系。 因为我们的应用程序在不同的网络中运行，所以我们可以将不同的端口映射到内部9000端口。

When we specify the flag -p 9000:9000 we are saying that the port 9000 in the host machine will map to the port 9000 in our process' network. Let's try changing that.

当我们指定标志-p 9000:9000 ，就是说主机中的端口9000将映射到我们进程的网络中的端口9000。 让我们尝试更改它。

Run docker run -p 5000:9000 dockerised-akka-http:0.1 to run our new image with a different port.

运行docker run -p 5000:9000 dockerised-akka-http:0.1以使用其他端口运行我们的新映像。

We can query the todos to make sure it works as expected:

我们可以查询todos以确保它能按预期工作：

使我们的图像更亮 (Making our image lighter)

For our last experiment, we will try to make our image lighter. At this point it uses over 700MB.

对于我们的上一个实验，我们将尝试使图像更亮。 此时，它使用了700MB以上。

First, let’s increase the version so we get a different tag and can compare them. Then add dockerBaseImage := "openjdk:8-jre-alpine" above where we change the packageName . Our build.sbt now looks like:

首先，让我们增加版本，以便获得一个不同的标签并可以对其进行比较。 然后在我们更改packageName上方添加dockerBaseImage := "openjdk:8-jre-alpine" 。 我们的build.sbt现在看起来像：

enablePlugins(JavaAppPackaging)

name := "akkahttp-quickstart"version := "0.2"scalaVersion := "2.12.6"

dockerBaseImage := "openjdk:8-jre-alpine"packageName in Docker := "dockerised-akka-http"

val akkaVersion = "2.5.13"val akkaHttpVersion = "10.1.3"val circeVersion = "0.9.3"

libraryDependencies ++= Seq(  "com.typesafe.akka" %% "akka-actor" % akkaVersion,  "com.typesafe.akka" %% "akka-testkit" % akkaVersion % Test,  "com.typesafe.akka" %% "akka-stream" % akkaVersion,  "com.typesafe.akka" %% "akka-stream-testkit" % akkaVersion % Test,  "com.typesafe.akka" %% "akka-http" % akkaHttpVersion,  "com.typesafe.akka" %% "akka-http-testkit" % akkaHttpVersion % Test,  "io.circe" %% "circe-core" % circeVersion,  "io.circe" %% "circe-generic" % circeVersion,  "io.circe" %% "circe-parser" % circeVersion,  "de.heikoseeberger" %% "akka-http-circe" % "1.21.0",  "org.scalatest" %% "scalatest" % "3.0.5" % Test)

We are using a different tag of the openjdk base image to specify that we want to use alpine, which is a lightweight Linux distribution.

我们使用openjdk基本映像的不同标记来指定我们要使用alpine ，这是轻量级的Linux发行版。

Publish the image by running sbt docker:publishLocal. Get the images with docker images . We can see that the image is lighter now:

通过运行sbt docker:publishLocal发布映像。 使用docker images获取docker images 。 我们可以看到图像现在变亮了：

REPOSITORY             TAG   IMAGE ID       CREATED          SIZE dockerised-akka-http   0.2   4688366e70bb   32 seconds ago   119MB akkahttp-quickstart    0.1   d03732dd0854   2 hours ago      774MBdockerised-akka-http   0.1   d03732dd0854   2 hours ago      774MB

Let’s make sure that it still works.

让我们确保它仍然有效。

Run docker run -p 5000:9000 dockerised-akka-http:0.2, minding the tag number. It's not working, ad we get the following error:

运行docker run -p 5000:9000 dockerised-akka-http:0.2 ，注意标记号。 它不起作用，并且出现以下错误：

env: can't execute 'bash': No such file or directory

Apparently, our dockerised application needs bash to run. Reading the plugin’s documentation, we can tell that it generates a bash script that executes our application.

显然，我们的dockerized应用程序需要运行bash 。 阅读插件的文档 ，我们可以知道它生成了一个执行我们的应用程序的bash脚本。

So let’s install bash in our image and try again.

因此，让我们在映像中安装bash并重试。

Add the following lines below where we change the packageName in our build.sbt file:

在更改build.sbt文件中的packageName位置以下添加以下行：

import com.typesafe.sbt.packager.docker._dockerCommands ++= Seq(  Cmd("USER", "root"),  ExecCmd("RUN", "apk", "add", "--no-cache", "bash"))

We are adding some extra commands to our Dockefile. We are changing the user to root to install the package, and then we install bash.

我们在Dockefile中添加了一些额外的命令。 我们将用户更改为root来安装软件包，然后安装bash。

Let’s try running the application again, docker run -p 5000:9000 dockerised-akka-http:0.2. And it's working now, great!

让我们尝试再次运行该应用程序， docker run -p 5000:9000 dockerised-akka-http:0.2 。 现在就可以了，太好了！

If we check the images again, the alpine-based one is a bit bigger, like 10MB. That’s nothing compared to the roughly 770MB of the others.

如果我们再次检查图像，则基于阿尔卑斯的图像会更大一些，例如10MB。 与其他大约770MB的存储空间相比，这没什么。

Installing bash in alpine isn’t the worst thing in the world. Some people end up adding it anyway due to their preference and for debugging.

在高山上安装bash并不是世界上最糟糕的事情。 某些人由于偏好和调试而最终还是添加了它。

生成与Ash兼容的可执行文件 (Generating an Ash-compatible executable)

Installing bash on our image is a bit of a workaround. Let’s use an additional plugin to generate an executable that is compatible with Alpine. Thanks to Muki Seller for letting us know about this solution!

在我们的映像上安装bash有点解决方法。 让我们使用一个附加插件来生成与Alpine兼容的可执行文件。 感谢Muki Seller让我们知道此解决方案！

According to the official documentation, we need to enable the extra plugin AshScriptPlugin.

根据官方文档 ，我们需要启用额外的插件AshScriptPlugin 。

Modify the build.sbt file to enable both plugins, and remove the previous workaround:

修改build.sbt文件以启用两个插件，并删除以前的解决方法：

enablePlugins(JavaAppPackaging, AshScriptPlugin)

name := "akkahttp-quickstart"version := "0.3"scalaVersion := "2.12.6"

dockerBaseImage := "openjdk:8-jre-alpine"packageName in Docker := "dockerised-akka-http"

val akkaVersion = "2.5.13"val akkaHttpVersion = "10.1.3"val circeVersion = "0.9.3"

libraryDependencies ++= Seq(  "com.typesafe.akka" %% "akka-actor" % akkaVersion,  "com.typesafe.akka" %% "akka-testkit" % akkaVersion % Test,  "com.typesafe.akka" %% "akka-stream" % akkaVersion,  "com.typesafe.akka" %% "akka-stream-testkit" % akkaVersion % Test,  "com.typesafe.akka" %% "akka-http" % akkaHttpVersion,  "com.typesafe.akka" %% "akka-http-testkit" % akkaHttpVersion % Test,

"io.circe" %% "circe-core" % circeVersion,  "io.circe" %% "circe-generic" % circeVersion,  "io.circe" %% "circe-parser" % circeVersion,  "de.heikoseeberger" %% "akka-http-circe" % "1.21.0",

"org.scalatest" %% "scalatest" % "3.0.5" % Test)

We also increased the version so we can compare and avoid overriding the previous one.

我们还增加了版本，以便我们可以比较并避免覆盖上一个版本。

Run sbt docker:publishLocal, and then docker run dockerised-akka-http:0.3.

运行sbt docker:publishLocal ，然后docker run dockerised-akka-http:0.3 。

You should see the success message and, if you query for the todos, you should see them as well. Great!

您应该看到成功消息，并且，如果您查询待办事项，那么您也应该看到它们。 大！

结论 (Conclusion)

In this tutorial we dockerised a Scala and Akka HTTP application. There was nothing done specifically for this application which means that the setup will work pretty much as it is.

在本教程中，我们泊坞了Scala和Akka HTTP应用程序。 没有为该应用程序专门做任何事情，这意味着安装程序将按原样工作。

Then we looked at how to accomplish some common use cases by customising our Dockerfile through the plugin.

然后，我们研究了如何通过插件自定义Dockerfile来完成一些常见用例。

We even managed to reduce the image size by nearly seven times!

我们甚至设法将图像尺寸减小了近七倍！

Amazing, isn’t it?

太神奇了，不是吗？

If you liked this tutorial and want to learn how to build an API for a todo application, check out our new free course! ???

如果您喜欢本教程，并且想学习如何为todo应用程序构建API，请查看我们的新免费课程 ！ ???

Originally published at www.codemunity.io.

最初在www.codemunity.io上发布。

翻译自: https://www.freecodecamp.org/news/how-to-dockerise-a-scala-and-akka-http-application-the-easy-way-23310fc880fa/

scala akka