To start the Artemis application server from the development
environment, first import the project into IntelliJ and then make sure
to install the Spring Boot plugins to run the main class
de.tum.in.www1.artemis.ArtemisApp. Before the application runs, you
have to change some configuration options.
You can change the options directly in the file
application-artemis.yml in the folder
src/main/resources/config. However, you have to be careful that you do not
accidentally commit your password. Therefore, we strongly recommend, to create a new file
application-local.yml in the folder
src/main/resources/config which is ignored by default.
You can override the following configuration options in this file.
bcrypt-salt-rounds: 11 # The number of salt rounds for the bcrypt password hashing. Lower numbers make it faster but more unsecure and vice versa.
# Please use the bcrypt benchmark tool to determine the best number of rounds for your system. https://github.com/ls1intum/bcrypt-Benchmark
credential-provider: <provider> # The credential provider which users can log in though (e.g. TUMonline)
links: # The password reset links for different languages
user: <username> # e.g. ga12abc
user: <username> # e.g. ga12abc
token: <token> # VCS API token giving Artemis full Admin access. Not needed for Bamboo+Bitbucket
user: <username> # e.g. ga12abc
token: <token> # Enter a valid token generated by bamboo or leave this empty to use the fallback authentication user + password
# Some CI systems, like Jenkins, offer a specific token that gets checked against any incoming notifications
# from a VCS trying to trigger a build plan. Only if the notification request contains the correct token, the plan
# is triggered. This can be seen as an alternative to sending an authenticated request to a REST API and then
# triggering the plan.
# In the case of Artemis, this is only really needed for the Jenkins + GitLab setup, since the GitLab plugin in
# Jenkins only allows triggering the Jenkins jobs using such a token. Furthermore, in this case, the value of the
# hudson.util.Secret is stored in the build plan, so you also have to specify this encrypted string here and NOT the actual token value itself!
# You can get this by GETting any job.xml for a job with an activated GitLab step and your token value of choice.
secret-push-token: <token hash>
# Key of the saved credentials for the VCS service
# Bamboo: not needed
# Jenkins: You have to specify the key from the credentials page in Jenkins under which the user and
# password for the VCS are stored
vcs-credentials: <credentials key>
# Key of the credentials for the Artemis notification token
# Bamboo: not needed
# Jenkins: You have to specify the key from the credentials page in Jenkins under which the notification token is stored
notification-token: <credentials key>
# The actual value of the notification token to check against in Artemis. This is the token that gets send with
# every request the CI system makes to Artemis containing a new result after a build.
# Bamboo: The token value you use for the Server Notification Plugin
# Jenkins: The token value you use for the Server Notification Plugin and is stored under the notification-token credential above
Change all entries with
<...> with proper values, e.g. your TUM
Online account credentials to connect to the given instances of JIRA,
Bitbucket and Bamboo. Alternatively, you can connect to your local JIRA,
Bitbucket and Bamboo instances. It’s not necessary to fill all the
fields, most of them can be left blank. Note that there is additional
information about the setup for programming exercises provided:
Be careful that you do not commit changes to
To avoid this, follow the best practice when configuring your local development environment:
Create a file named
Copy the contents of
application-artemis.ymlinto the new file.
Update configuration values in
By default, changes to
application-local.yml will be ignored by git so you don’t accidentally
share your credentials or other local configuration options. The run configurations contain a profile
local at the end to make sure the
application-local.yml is considered. You can create your own
application-<name>.yml and then activate the profile
<name> in the run
configuration if you need additional customizations.
If you use a password, you need to adapt it in
Run the server via Docker
5.7.1 can be retrieved as
You can find the latest Artemis Dockerfile at
The Dockerfile has multiple stages: A builder stage, building the
.warfile, an optional external_builder stage to import a pre-built
.warfile, a war_file stage to choose between the builder stages via build argument and a runtime stage with minimal dependencies just for running artemis.
The Dockerfile defines three Docker volumes (at the specified paths inside the container):
This can be used to store additional configurations of Artemis in YAML files. The usage is optional, and we recommend using the environment files for overriding your custom configurations instead of using
src/main/resources/application-local.ymlas such an additional configuration file. The other configurations like
src/main/resources/application.yml, … are built into the
.warfile and therefore are not needed in this directory.
Instead of mounting this config directory, you can also use environment variables for the configuration as defined by the Spring relaxed binding. You can either place those environment variables directly in the
environmentsection, or create an .env-file. When starting an Artemis container directly with the Docker-CLI, an .env-file can also be given via the
To ease the transition of an existing set of YAML configuration files into the environment variable style, a helper script can be used.
This directory should be used for any data (e.g., local clone of repositories). This is preconfigured in the
dockerJava Spring profile (which sets the following values:
This directory will be used for branding. You can specify a favicon here.
The Dockerfile assumes that the mounted volumes are located on a file system with the following locale settings (see #4439 for more details):
ARM64 Image builds might run out of memory if not provided with enough memory and/or swap space. On a Apple M1 we had to set the Docker Desktop memory limit to 12GB or more.
Debugging with Docker
With the following Java environment variable, you can configure the Remote Java Debugging inside a container:
Run the server via a run configuration in IntelliJ
The project comes with some pre-configured run / debug configurations that are stored in the
When you import the project into IntelliJ the run configurations will also be imported.
The recommended way is to run the server and the client separately. This provides fast rebuilds of the server and hot module replacement in the client.
Artemis (Server): The server will be started separated from the client. The startup time decreases significantly.
Other run / debug configurations
Artemis (Server & Client): Will start the server and the client. The client will be available at http://localhost:8080/ with hot module replacement disabled.
Artemis (Server, Jenkins & GitLab): The server will be started separated from the client with the profiles
Artemis (Server, LocalVC & LocalCI): The server will be started separated from the client with the profiles
dev,bamboo,bitbucket,jira,artemis. To use this configuration, Docker needs to be running on your system as the local CI system uses it to run build jobs.
Artemis (Server, LocalVC & LocalCI, Athena): The server will be started separated from the client with
athenaprofile and Local VC / CI enabled (see Athena Service).
Run the server with Spring Boot and Spring profiles
The Artemis server should startup by running the main class
de.tum.in.www1.artemis.ArtemisApp using Spring Boot.
Artemis uses Spring profiles to segregate parts of the
application configuration and make it only available in certain
environments. For development purposes, the following program arguments
can be used to enable the
dev profile and the profiles for JIRA,
Bitbucket and Bamboo:
If you use IntelliJ (Community or Ultimate) you can set the active profiles by
Run | Edit Configurations...
Going to the
Environmentsection to reveal
VM Optionsand setting them to
Set Spring profiles with IntelliJ Ultimate
If you use IntelliJ Ultimate, add the following entry to the section
Active Profiles (within
Spring Boot) in the server run
Run the server with the command line (Gradle wrapper)
If you want to run the application via the command line instead, make
sure to pass the active profiles to the
gradlew command like this:
./gradlew bootRun --args='--spring.profiles.active=dev,bamboo,bitbucket,jira,artemis,scheduling'
As an alternative, you might want to use Jenkins and GitLab with an internal user management in Artemis, then you would use the profiles: