fix: docker compose deployment

StellaLupus · StellaLupus · commit 17b35ec201d1 · 2023-12-26T15:39:11.000+03:00
diff --git a/comments-app-ktor/build.gradle.kts b/comments-app-ktor/build.gradle.kts
@@ -106,6 +106,12 @@ kotlin {
     }
 }
 
+ktor {
+    fatJar {
+        archiveFileName.set("${project.name}.jar")
+    }
+}
+
 
 tasks {
     val linkReleaseExecutableLinuxX64 by getting(KotlinNativeLink::class)
@@ -116,9 +122,11 @@ tasks {
 //    val nativeFile = linkDebugExecutableLinuxX64.binary.outputFile
     val linuxX64ProcessResources by getting(ProcessResources::class)
     val linuxArm64ProcessResources by getting(ProcessResources::class)
+    val jvmProcessResources by getting(ProcessResources::class)
     val dockerLinuxX64Dir = layout.buildDirectory.file("docker-x64/Dockerfile").get().asFile
     val dockerLinuxArm64Dir = layout.buildDirectory.file("docker-arm64/Dockerfile").get().asFile
     val dockerLinuxMultiplatformDir = layout.buildDirectory.file("docker-multiplatform/Dockerfile").get().asFile
+    val dockerJvmDir = layout.buildDirectory.file("docker-jvm/Dockerfile").get().asFile
 
     val dockerDockerfileX64 by creating(Dockerfile::class) {
         dependsOn(linkReleaseExecutableLinuxX64)
@@ -229,14 +237,57 @@ tasks {
         arg("TARGETPLATFORM")
         copyFile("\${TARGETPLATFORM}/${nativeFileArm64.name}", "/app/")
         copyFile("\${TARGETPLATFORM}/application.yaml", "/app/")
-        exposePort(8081)
+        exposePort(8080)
         workingDir("/app")
         entryPoint("/app/${nativeFileArm64.name}", "-config=./application.yaml")
     }
 
+    val dockerDockerfileJvm by creating(Dockerfile::class) {
+        dependsOn(buildFatJar)
+        dependsOn(shadowJar)
+        dependsOn(jvmProcessResources)
+        group = "docker"
+        destFile.set(dockerJvmDir)
+
+        doFirst {
+            copy {
+                from(layout.buildDirectory.dir("libs"))
+                from(jvmProcessResources.destinationDir)
+                into("${this@creating.destDir.get().dir("app")}")
+            }
+        }
+
+        from(Dockerfile.From("openjdk:17-alpine"))
+        destDir.get().dir("app").asFile.listFiles()?.forEach {
+            copyFile("app/${it.name}", "/app/")
+        }
+
+        exposePort(8080)
+        workingDir("/app")
+        entryPoint("java", "-jar", ktor.fatJar.archiveFileName.get())
+    }
+    val dockerBuildJvmImage by creating(DockerBuildImage::class) {
+        group = "docker"
+        dependsOn(dockerDockerfileJvm)
+        inputDir.set(dockerJvmDir.parentFile)
+        images.add("$imageName-jvm:${rootProject.version}")
+        images.add("$imageName-jvm:latest")
+    }
+    val dockerPushJvmImage by creating(DockerPushImage::class) {
+        group = "docker"
+        dependsOn(dockerBuildJvmImage)
+        images.set(dockerBuildJvmImage.images)
+        registryCredentials {
+            username.set(registryUser)
+            password.set(registryPass)
+            url.set("https://$registryHost/v1/")
+        }
+    }
+
 
     val deployMultiplatform by creating(Exec::class) {
         group = "build"
+        dependsOn(dockerPushJvmImage)
         dependsOn(dockerDockerfileMultiplatform)
         workingDir(dockerDockerfileMultiplatform.destDir)
         workingDir.list()?.forEach {
@@ -247,10 +298,10 @@ tasks {
         args("buildx", "build", "--platform", "linux/amd64,linux/arm64", "-t", "$imageName:${rootProject.version}", "-t", "$imageName:latest","--push", ".")
     }
 
-
     create("deploy") {
         group = "build"
         dependsOn(dockerPushX64Image)
         dependsOn(dockerPushArm64Image)
+        dependsOn(dockerPushJvmImage)
     }
 }
diff --git a/comments-app-ktor/src/jvmMain/kotlin/com/crowdproj/comments/app/cassandra/CassandraConfig.kt b/comments-app-ktor/src/jvmMain/kotlin/com/crowdproj/comments/app/cassandra/CassandraConfig.kt
@@ -7,13 +7,15 @@ data class CassandraConfig(
     val port: Int = 9042,
     val user: String = "cassandra",
     val pass: String = "cassandra",
-    val keyspace: String = "test_keyspace"
+    val keyspace: String = "test_keyspace",
+    val testing: Boolean = false
 ) {
     constructor(config: ApplicationConfig) : this(
         host = config.property("host").getString(),
         port = config.property("port").getString().toInt(),
         user = config.property("user").getString(),
         pass = config.property("pass").getString(),
-        keyspace = config.property("keyspace").getString()
+        keyspace = config.property("keyspace").getString(),
+        testing = config.propertyOrNull("testing")?.getString()?.toBoolean() ?: CassandraConfig().testing
     )
 }
diff --git a/comments-app-ktor/src/jvmMain/kotlin/com/crowdproj/comments/app/plugins/GetDatabaseConf.jvm.kt b/comments-app-ktor/src/jvmMain/kotlin/com/crowdproj/comments/app/plugins/GetDatabaseConf.jvm.kt
@@ -18,7 +18,7 @@ actual fun Application.getDatabaseConf(type: CommentDbType): ICommentsRepository
     )
 
     return when(dbType) {
-        "inmemory", "memory", "mem" -> initInMemory()
+        "inmemory", "memory", "mem" -> initInMemory(dbConfig)
         "cassandra", "cass" -> initCassandra(dbConfig)
         else -> throw IllegalArgumentException(
             "$dbSettingPath.type must be set in application.yml to one of: " +
@@ -28,19 +28,20 @@ actual fun Application.getDatabaseConf(type: CommentDbType): ICommentsRepository
 }
 
 
-private fun Application.initCassandra(dbConfig: ApplicationConfig): ICommentsRepository {
+private fun initCassandra(dbConfig: ApplicationConfig): ICommentsRepository {
     val config = CassandraConfig(dbConfig)
     return CommentsRepoCassandra(
         keyspaceName = config.keyspace,
         host = config.host,
         port = config.port,
         user = config.user,
         pass = config.pass,
+        testing = config.testing
     )
 }
 
-private fun Application.initInMemory(): ICommentsRepository {
-    val ttlSetting = environment.config.propertyOrNull("db.prod")?.getString()?.let {
+private fun initInMemory(dbConfig: ApplicationConfig): ICommentsRepository {
+    val ttlSetting = dbConfig.propertyOrNull("ttl")?.getString()?.let {
         Duration.parse(it)
     }
     return CommentsRepoInMemory(ttl = ttlSetting ?: 10.minutes)
diff --git a/comments-app-ktor/src/jvmMain/resources/application.yaml b/comments-app-ktor/src/jvmMain/resources/application.yaml
@@ -18,8 +18,9 @@ comments:
       type: inmemory
     prod:
       type: cassandra
-      host: localhost
-      port: 9042
-      user: cassandra
-      pass: cassandra
-      keyspace: test_keyspace
+      host: "$CASSANDRA_HOST:localhost"
+      port: "$CASSANDRA_PORT:9042"
+      user: "$CASSANDRA_USER:cassandra"
+      pass: "$CASSANDRA_PASS:cassandra"
+      keyspace: "$CASSANDRA_KEYSPACE:comments"
+      testing: "$CASSANDRA_TESTING:false"
diff --git a/deploy/docker-compose.yml b/deploy/docker-compose.yml
@@ -6,27 +6,58 @@
 version: "3"
 services:
 
-#  app:
-#    container_name: app
-#    image: nginx
-#    ports:
-#      - 8080:80
+  app:
+    container_name: app
+    image: stellalupus/crowdproj-comments-jvm
+    ports:
+      - 8080:8080
 #    volumes:
 #      # добавляем конфигурацию в контейнер
 #      - ./nginx/nginx.conf:/etc/nginx/nginx.conf
-#    depends_on:
-#      - fluent-bit
-#    logging:
-#      # используемый драйвер логгирования
-#      driver: "fluentd"
-#      options:
-#        # куда посылать лог-сообщения
-#        # необходимо чтобы адрес совпадал с настройками плагина forward
-#        fluentd-address: localhost:24224
-#        # теги используются для маршрутизации лог-сообщений
-#        tag: app.logs
-#    networks:
-#      - opensearch
+    environment:
+      CASSANDRA_HOST: cassandra
+      CASSANDRA_TESTING: true
+    depends_on:
+      - fluent-bit
+      - cassandra
+    logging:
+      # используемый драйвер логгирования
+      driver: "fluentd"
+      options:
+        # куда посылать лог-сообщения
+        # необходимо чтобы адрес совпадал с настройками плагина forward
+        fluentd-address: localhost:24224
+        # теги используются для маршрутизации лог-сообщений
+        tag: app.logs
+    networks:
+      - opensearch
+
+  cassandra:
+    image: cassandra:3.11.16   # better to use a specific version, if you want to control upgrades
+    container_name: cassandra
+
+    healthcheck:
+      test: [ "CMD", "cqlsh", "-e", "describe keyspaces" ]
+      interval: 5s
+      timeout: 5s
+      retries: 60
+    volumes:
+      - ./volumes/cassandra:/var/lib/cassandra
+    environment:    # Declare and save environments variables into "environment"
+      CASSANDRA_SNITCH: GossipingPropertyFileSnitch
+      JVM_OPTS: -Dcassandra.skip_wait_for_gossip_to_settle=0 -Dcassandra.initial_token=0
+      HEAP_NEWSIZE: 128M
+      MAX_HEAP_SIZE: 1024M
+      CASSANDRA_ENDPOINT_SNITCH: GossipingPropertyFileSnitch
+      CASSANDRA_DC: datacenter1
+    networks:
+      opensearch:
+        aliases:
+          - cassandra
+    deploy:
+      resources:
+        limits:
+          memory: 2G  # It's not strictly required, but it's better to have some memory limit
 
   fluent-bit:
     container_name: fluent-bit
diff --git a/gradle/libs.versions.toml b/gradle/libs.versions.toml
@@ -44,6 +44,7 @@ ktor-server-call-logging = { module = "io.ktor:ktor-server-call-logging", versio
 ktor-server-default-headers = { module = "io.ktor:ktor-server-default-headers", version.ref = "ktor" }
 ktor-server-call-id = { module = "io.ktor:ktor-server-call-id", version.ref = "ktor" }
 ktor-server-swagger = { module = "io.ktor:ktor-server-swagger", version.ref = "ktor" }
+ktor-server-forwarded-header = { module = "io.ktor:ktor-server-forwarded-header", version.ref = "ktor" }
 #KTOR Serialization
 ktor-serialization-jackson = { module = "io.ktor:ktor-serialization-jackson", version.ref = "ktor" }
 #KTOR Client

Original file line number	Diff line number	Diff line change
`@@ -18,7 +18,7 @@ actual fun Application.getDatabaseConf(type: CommentDbType): ICommentsRepository`
`18`	`18`	`)`
`19`	`19`
`20`	`20`	`return when(dbType) {`
`21`		`- "inmemory", "memory", "mem" -> initInMemory()`
	`21`	`+ "inmemory", "memory", "mem" -> initInMemory(dbConfig)`
`22`	`22`	`"cassandra", "cass" -> initCassandra(dbConfig)`
`23`	`23`	`else -> throw IllegalArgumentException(`
`24`	`24`	`"$dbSettingPath.type must be set in application.yml to one of: " +`
`@@ -28,19 +28,20 @@ actual fun Application.getDatabaseConf(type: CommentDbType): ICommentsRepository`
`28`	`28`	`}`
`29`	`29`
`30`	`30`
`31`		`-private fun Application.initCassandra(dbConfig: ApplicationConfig): ICommentsRepository {`
	`31`	`+private fun initCassandra(dbConfig: ApplicationConfig): ICommentsRepository {`
`32`	`32`	`val config = CassandraConfig(dbConfig)`
`33`	`33`	`return CommentsRepoCassandra(`
`34`	`34`	`keyspaceName = config.keyspace,`
`35`	`35`	`host = config.host,`
`36`	`36`	`port = config.port,`
`37`	`37`	`user = config.user,`
`38`	`38`	`pass = config.pass,`
	`39`	`+ testing = config.testing`
`39`	`40`	`)`
`40`	`41`	`}`
`41`	`42`
`42`		`-private fun Application.initInMemory(): ICommentsRepository {`
`43`		`- val ttlSetting = environment.config.propertyOrNull("db.prod")?.getString()?.let {`
	`43`	`+private fun initInMemory(dbConfig: ApplicationConfig): ICommentsRepository {`
	`44`	`+ val ttlSetting = dbConfig.propertyOrNull("ttl")?.getString()?.let {`
`44`	`45`	`Duration.parse(it)`
`45`	`46`	`}`
`46`	`47`	`return CommentsRepoInMemory(ttl = ttlSetting ?: 10.minutes)`