PluginBench
Skill
Official
Fail
Audit score 45

create-spring-boot-kotlin-project

github/awesome-copilot

Generate a Spring Boot 3.4.5 Kotlin project skeleton with PostgreSQL, Redis, MongoDB, and Docker Compose.

What is create-spring-boot-kotlin-project?

Creates a production-ready Spring Boot Kotlin project template with Java 21, Gradle, and pre-configured reactive data access, caching, and API documentation. Use this when you need a new Kotlin-based Spring Boot microservice with multi-database support and containerized dependencies.

  • Downloads Spring Boot 3.4.5 project template with Kotlin and Gradle
  • Configures reactive data access (R2DBC PostgreSQL, MongoDB, Redis)
  • Adds SpringDoc OpenAPI for Swagger UI documentation
  • Includes ArchUnit for architecture testing
  • Sets up Docker Compose with PostgreSQL 17, Redis 6, and MongoDB 8
  • Pre-configures application properties for all services

How to install create-spring-boot-kotlin-project

npx skills add https://github.com/github/awesome-copilot --skill create-spring-boot-kotlin-project
Prerequisites
  • Java 21 installed
  • Docker installed
  • Docker Compose installed
Claude Code
Cursor
Windsurf
Cline

How to use create-spring-boot-kotlin-project

  1. 1.Run `java -version` to verify Java 21 is installed
  2. 2.Execute the curl command to download the Spring Boot template (customize artifactId and bootVersion if needed)
  3. 3.Unzip the downloaded starter.zip file to your project directory
  4. 4.Remove the starter.zip file
  5. 5.Add springdoc-openapi and archunit dependencies to build.gradle.kts
  6. 6.Insert SpringDoc, Redis, R2DBC, and MongoDB configurations into application.properties
  7. 7.Create docker-compose.yaml at project root with Redis, PostgreSQL, and MongoDB services
  8. 8.Add data directories to .gitignore

Use cases

Good for
  • Starting a new Kotlin microservice with reactive database access
  • Building an API-first application with Swagger documentation
  • Setting up a multi-database project with Redis caching and PostgreSQL persistence
  • Creating a containerized development environment with Docker Compose
  • Establishing architecture testing patterns with ArchUnit
Who it's for
  • Kotlin developers
  • Spring Boot microservice teams
  • Backend engineers using reactive programming
  • Teams requiring OpenAPI/Swagger documentation

create-spring-boot-kotlin-project FAQ

How do I customize the project name?

Change the `artifactId` and `packageName` parameters in the curl command before downloading the template.

Can I use a different Spring Boot version?

Yes, modify the `bootVersion` parameter in the download command. The default is 3.4.5.

What databases are included?

PostgreSQL 17 (R2DBC), Redis 6 (caching), and MongoDB 8 (document storage) are all configured in Docker Compose.

Do I need to start Docker services manually?

Yes, run `docker-compose up -d` to start the services. They are defined in docker-compose.yaml but not started automatically.

What is ArchUnit used for?

ArchUnit enables architecture testing to enforce coding standards and design rules in your Spring Boot project.

Full instructions (SKILL.md)

Source of truth, from github/awesome-copilot.


name: create-spring-boot-kotlin-project description: 'Create Spring Boot Kotlin Project Skeleton'

Create Spring Boot Kotlin project prompt

Check Java version

  • Run following command in terminal and check the version of Java
java -version

Download Spring Boot project template

  • Run following command in terminal to download a Spring Boot project template
curl https://start.spring.io/starter.zip \
  -d artifactId=${input:projectName:demo-kotlin} \
  -d bootVersion=3.4.5 \
  -d dependencies=configuration-processor,webflux,data-r2dbc,postgresql,data-redis-reactive,data-mongodb-reactive,validation,cache,testcontainers \
  -d javaVersion=21 \
  -d language=kotlin \
  -d packageName=com.example \
  -d packaging=jar \
  -d type=gradle-project-kotlin \
  -o starter.zip

Unzip the downloaded file

  • Run following command in terminal to unzip the downloaded file
unzip starter.zip -d ./${input:projectName:demo-kotlin}

Remove the downloaded zip file

  • Run following command in terminal to delete the downloaded zip file
rm -f starter.zip

Unzip the downloaded file

  • Run following command in terminal to unzip the downloaded file
unzip starter.zip -d ./${input:projectName:demo-kotlin}

Add additional dependencies

  • Insert springdoc-openapi-starter-webmvc-ui and archunit-junit5 dependency into build.gradle.kts file
dependencies {
  implementation("org.springdoc:springdoc-openapi-starter-webflux-ui:2.8.6")
  testImplementation("com.tngtech.archunit:archunit-junit5:1.2.1")
}
  • Insert SpringDoc configurations into application.properties file
# SpringDoc configurations
springdoc.swagger-ui.doc-expansion=none
springdoc.swagger-ui.operations-sorter=alpha
springdoc.swagger-ui.tags-sorter=alpha
  • Insert Redis configurations into application.properties file
# Redis configurations
spring.data.redis.host=localhost
spring.data.redis.port=6379
spring.data.redis.password=rootroot
  • Insert R2DBC configurations into application.properties file
# R2DBC configurations
spring.r2dbc.url=r2dbc:postgresql://localhost:5432/postgres
spring.r2dbc.username=postgres
spring.r2dbc.password=rootroot

spring.sql.init.mode=always
spring.sql.init.platform=postgres
spring.sql.init.continue-on-error=true
  • Insert MongoDB configurations into application.properties file
# MongoDB configurations
spring.data.mongodb.host=localhost
spring.data.mongodb.port=27017
spring.data.mongodb.authentication-database=admin
spring.data.mongodb.username=root
spring.data.mongodb.password=rootroot
spring.data.mongodb.database=test
  • Create docker-compose.yaml at project root and add following services: redis:6, postgresql:17 and mongo:8.

    • redis service should have
      • password rootroot
      • mapping port 6379 to 6379
      • mounting volume ./redis_data to /data
    • postgresql service should have
      • password rootroot
      • mapping port 5432 to 5432
      • mounting volume ./postgres_data to /var/lib/postgresql/data
    • mongo service should have
      • initdb root username root
      • initdb root password rootroot
      • mapping port 27017 to 27017
      • mounting volume ./mongo_data to /data/db
  • Insert redis_data, postgres_data and mongo_data directories in .gitignore file

  • Run gradle clean test command to check if the project is working

./gradlew clean test
  • (Optional) docker-compose up -d to start the services, ./gradlew spring-boot:run to run the Spring Boot project, docker-compose rm -sf to stop the services.

Let's do this step by step.