Daytona · Dev Environment Management Platform

22.05.2024Stefan Welsch
DevOps Developer Experience DevOps Cloud Computing Productivity Development Integration Build Automation

Banner

Daytona ist eine Plattform für das Management von Entwicklungsumgebungen (DEM), die Anfang 2023 eingeführt wurde. Das Team hinter Daytona entwickelte ursprünglich Codeanywhere, eine der ersten cloudbasierten integrierten Entwicklungsumgebungen. Nachdem sie die Grenzen von Codeanywhere erkannt hatten und die sich entwickelnden Bedürfnisse der Entwicklergemeinschaft bemerkten, beschlossen sie, eine robustere und flexiblere Lösung zu schaffen, was zur Geburt von Daytona führte.

Daytona verspricht dabei eine effiziente Verwaltung von Entwicklungsumgebungen. Laut der Daytona Seite gibt es sogar das folgende Statement:

Daytona is a radically simple open source development environment manager. (Daytona ist ein radikal einfacher Open-Source-Manager für Entwicklungsumgebungen.)

Aber was macht Daytona denn nun genau? Hier ein paar Details, welche man auf der Webseite lesen kann.

Mit Daytona wird die gesamte Entwicklungsumgebung von Grund auf automatisiert. Es beginnt mit der Bereitstellung der notwendigen Instanz und der intelligenten Interpretation sowie Anwendung der gewünschten Konfiguration. Anschließend richtet Daytona Prebuilds ein, die den Entwicklern sofort einsatzbereite Umgebungen bieten. Die sichere VPN-Verbindung sorgt dafür, dass alle Daten geschützt sind, während die Möglichkeit, sowohl lokale als auch Web-IDEs zu verbinden, maximale Flexibilität bietet.

Mit Daytona wird der gesamte Entwicklungsprozess nahtlos und effizient gestaltet, sodass Sie und Ihr Team sich auf das Wesentliche konzentrieren können: das Schreiben des Codes.

Zunächst muss ich erwähnen, dass ich anfangs viel Geduld gebraucht habe, damit ich Daytona benutzen konnte. Es gab dabei verschiedene Arten von Fehlern, aber letztendlich hat es dann doch geklappt. Ich werde im Verlauf des Techups noch auf die einzelnen Fehler eingehen. Ausserdem ist wichtig zu erwähnen, dass ich mir ausschliesslich die Open-Source Version von Daytona angeschaut habe, welche seit dem 06. März 2024 verfügbar ist und damit auch noch sehr jung ist. Dies ist wichtig zu erwähnen, da der Funktionsumfang von der Open-Source Variante und der Enterprise Variante wohl sehr unterschiedlich ist.

Aber wollen wir uns nun mal anschauen, wie das Ganze in der Praxis aussieht.

Setup

Als Erstes installieren wir die Daytona CLI. Dazu führen wir in einem Terminal den folgenden Befehl aus:

1
(curl -sf -L https://download.daytona.io/daytona/install.sh | sudo bash) && daytona server -y && daytona

Daraufhin erhalten wir die folgende Ausgabe:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
Default installation directory: /usr/local/bin
You can override this by setting the DAYTONA_PATH environment variable (ie. `| DAYTONA_PATH=/home/user/bin bash`)

Downloading Daytona binary from https://download.daytona.io/daytona/latest/daytona-darwin-arm64
Installing server to /usr/local/bin
INFO[0000] Using default FRPS config

 Starting the Daytona Server daemon...


    Daytona

   ## Daytona Server is running on port: 3000

   ===

   You may now begin developing




                    -#####=
                   -######-                       Daytona
         +###=   -######:                         The future of dev environments
         ####* -#####%-.............
         ####*######:=##############-             v0.14.0
         ####* =%#-  =##############-
   :*%=  ####*        ....:*#:......              -------------------------------------------------------------
  =####%==+++-           +####*.
   :*####%=               =%####+.                Get started
     .*####%=               =%####+.
       .*###*.          .####-=%####*.            > daytona create (create a new workspace)
    :::::=%+:::::    .  .####:  =%##%-              daytona code (open a workspace in your preferred IDE)
    #############  .*#%-.####:    +-                daytona git-provider add (register a Git provider account)
    %%%%%%%%%%%%%.*####%=####:                      daytona target set (run workspaces on a remote machine)
               .*####%= .####:
             .*####%=   .####:                      view all commands
             +%##%=      ****:

Erster Workspace

Wir können nun direkt loslegen und einen neuen Workspace erstellen. Wir wählen also den Punkt daytona create aus. Hier können wir einfach eine Git-Url und einen Workspace Namen eingeben um zu starten.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
daytona create

┃ Primary project repository
┃ > https://github.com/b-nova-techhub/jdk-22.git

┃ Workspace name
┃ > jdk-22

Creating workspace
Initializing network
Network initialized
Creating project jdk-22
Pulling image...
latest: Pulling from daytonaio/workspace-project
Digest: sha256:7efe078cc2a2f8807e3ddc3bb9afbff62033b27f221226187ebe0435e9ebdddc
Status: Image is up to date for daytonaio/workspace-project:latest
Image pulled successfully
Workspace creation complete. Pending start...
Starting workspace
Workspace jdk-22 started
Project jdk-22 created
Starting project jdk-22
Project jdk-22 started
Downloading Daytona binary from https://api-0cb1db14-b97a-4816-9b82-28a76f8b25f3.try-eu.daytona.app/binary/v0.14.0/daytona-linux-arm64
Installing server to /usr/local/bin
Starting Daytona Agent
Cloning repository...
Enumerating objects: 80, done.
Counting objects: 100% (80/80), done.
Compressing objects: 100% (44/44), done.
Total 80 (delta 10), reused 76 (delta 8), pack-reused 0
Repository cloned
Running post start commands...
Running command: sudo dockerd
Starting ssh server on port 2222...


   Workspace       jdk-22

   Editor          VS Code

   State           RUNNING

   Repository      github.com/b-nova-techhub/jdk-22.git


 Run 'daytona code' when you're ready to start developing

Sobald die Informationen eingegeben wurde, wird der Workspace initialisiert. In der Log-Ausgabe sehen wir, dass ein daytonaio/workspace-project Docker-Image heruntergeladen wird, mit welchem uns später unser Workspace provisioniert wird. Wie wir hier schon sehen können, brauchen wir Docker auf unserem Rechner, im Daytona nutzen zu können. Danach wird noch das Daytona Binary installiert und ein SSH Daemon gestartet.

Sobald alles fertig initialisiert ist, können wir das Projekt lokal öffnen. Dazu können wir im Terminal einfach den folgenden Befehl eingeben.

1
2
3
4
5
6
7
8
9
daytona code

Select a Workspace To Open

      1 item

    │ jdk-22
    │ 3ca14393e356 (local)
    │ jdk-22

Wir sehen unseren Workspace und können diesen einfach auswählen. Es erscheint die folgende Meldung und es öffnet sich VSCode mit dem gewünschten Projekt.

1
Opening the project 'jdk-22' from workspace 'jdk-22' in your preferred IDE

image-20240514082655182

Aber wo genau läuft denn unser Projekt jetzt? Wie wir sehen können, wird eine SSH Verbindung zu unserem Projekt hergestellt. Der aufmerksame Leser hat gesehen, dass bei der Initialisierung ein Docker Container gestartet wurde. Schauen wir uns einmal die laufenden Container auf dem System an.

image-20240514083138376

Unser Projekt läuft also in einem Docker Container, mit welchem wir uns per SSH verbinden können.

Wer nun nicht gerne mit VSCode arbeitet, für den gibt es eine gute Nachricht. Daytona bietet auch andere Entwicklungsumgebungen an. Eine Liste können wir uns mit dem folgenden Befehl ausgeben lassen.

1
daytona ide

image-20240514083351085

Ich oute mich hier mal als IntelliJ User und wähle als default IDE also “IntelliJ IDEA Ultimate” aus.

Nun können wir wieder den Befehl daytona code ausführen und es sollte sich IntelliJ öffnen.

Leider funktioniert das nicht so einfach wie bei VSCode. Beim Öffnen des Projekts kam erstmal der folgende Fehler:

![Screenshot 2024-05-06 at 13.42.53](Screenshot 2024-05-06 at 13.42.53.png)

Dieser Fehler ist allerdings schnell gelöst. Wir müssen erstmal das Jetbrains Gateway installieren, damit wir eine Remoteverbindung zu unserem Docker Container aufbauen können. Es wird dann eine SSH Remote Connection hergestellt und IntelliJ gestartet. Leider wurde beim Starten dann auch wieder ein Fehler geworfen.

image-20240514074119193

Es hat mich gewundert das hier eine relativ alte IntelliJ Version (2023.2.2) verwendet wird, welche fix im Code hinterlegt ist. Daher habe ich beschlossen einen Pull Request zu erstellen in dem dann immer die aktuellste Version genommen wird. https://github.com/daytonaio/daytona/pull/541

Leider konnte ich diesen Fehler aber nicht lösen und muss wohl doch erstmal mit VSCode weiterarbeiten.

Schauen wir uns aber mal an, was Daytona uns weiterhin noch anbietet. Wenn man in der Konsole daytona --help eingibt, erhält man eine Übersicht aller Kommandos, welche die CLI unterstützt.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
daytona --help
Daytona is a Dev Environment Manager

Usage:
  daytona [flags]
  daytona [command]

Available Commands:
  api-key            Api Key commands
  autocomplete       Adds completion script for your shell enviornment
  code               Open a workspace in your preferred IDE
  container-registry Manage container registries
  create             Create a workspace
  delete             Delete a workspace
  forward            Forward a port from a project to your local machine
  git-providers      Manage Git providers
  help               Help about any command
  ide                Choose the default IDE
  info               Show workspace info
  list               List workspaces
  profile            Manage profiles
  provider           Manage providers
  purge              Purges all Daytona data from the current device
  serve              Run the server process in the current terminal session
  server             Start the server process in daemon mode
  ssh                SSH into a project using the terminal
  start              Start a workspace
  stop               Stop a workspace
  target             Manage provider targets
  use                Set the active profile
  version            Print the version number
  whoami             Display information about the active user

Flags:
      --help            help for daytona
  -o, --output string   Output format. Must be one of (yaml, json)

Use "daytona [command] --help" for more information about a command.

Git Providers

Ich will jetzt nicht auf alle Kommandos eingehen, aber mal ein paar rauspicken, welche noch ganz interessant sind. Mit git-providers kann man sich, wie der Name schon sagt verschiedene Git Anbieter bei Daytona hinterlegen, auf die man dann zugreifen kann.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
daytona git-providers add

┃ Choose a Git provider
┃ > GitHub
┃   GitLab
┃   GitLab Self-managed
┃   Bitbucket
┃   Codeberg
┃   Gitea

More information on:
 https://docs.github.com/en/authentication/keeping-your-account-and-data-secure/managing-your-personal-access-tokens#creating-a-personal-access-token-classic


┃ Personal access token
┃ >

Wollen wir uns das am Beispiel Github mal anschauen. Um einen neuen Git Anbieter hinzuzufügen, benötigt man einen Personal Access Token, damit man auch Zugriff auf Non-Public Repositories hat. Geben wir nun wieder daytona create ein, sehen wir das wir den bereits angelegten Git Anbieter, in unserem Fall Github, auswählen können.

image-20240515081502629

Wenn wir Github nun selektieren, sehen wir alle persönlichen Repositories und können hier eins auswählen. Leider habe ich es nicht geschafft auch die Firmen Repositories anzuzeigen. Deswegen ist die Funktion aktuell für meine Zwecke nicht wirklich brauchbar und ich muss den Umweg über die Eingabe einer Custom Repository URL gehen, was aber auch nicht wirklich schlimm ist.

Ein weiteres interessantes Kommando ist profile. Damit können wir theoretisch mehrere API-Server nutzen. Vorstellbar wäre hier zum Beispiel für verschiedene Cloud Provider verschiedene Profile zu erstellen, wo der API Server deployed ist.

image-20240515093212116

Noch zu erwähnen ist provider. Damit können wir bestimmen, wie unsere Container zur Verfügung gestellt werden. In der OpenSource Variante gibt es hier nur den Docker Provider.

Da Daytona ja wie bereits erwähnt Open-Source ist, kann man sich hier wohl aber nach Lust und Laune weitere Provider schreiben, was ich mir aber nicht angeschaut habe. In der Enterprise Variante wird aber wohl auch Kubernetes und OpenShift unterstützt.

Fazit

Daytona ist von der Idee her super, allerdings ist die Open-Source Variante noch sehr rudimentär gehalten und auch noch stark verbesserungsbedürftig. Leider gibt es auch nicht wirklich eine Dokumentation, aus welcher man sich die Informationen ziehen kann. Auch hier müsste noch nachgebessert werden. Daytona soll wohl durch ein Plugin-Prinzip erweiterbar sein, aber auch hierzu findet man auf der Github Seite derzeit noch keinerlei Informationen. Ich werde das Produkt aber auf jeden Fall weiter im Auge behalten und für interne Projekte auch mal im Team versuchen. Wer gerne über das Thema up-to-date gehalten werden möchte, der kann mir gerne auf LinkedIn folgen.

Stefan Welsch

Stefan Welsch – Manitu, Pionier, Stuntman, Mentor. Als Gründer von b-nova ist Stefan immer auf der Suche nach neuen und vielversprechenden Entwicklungsfeldern. Er ist durch und durch Pragmatiker und schreibt daher auch am liebsten Beiträge die sich möglichst nahe an 'real-world' Szenarien anlehnen.