This documentation provides a comprehensive step-by-step guide on how Docker is utilized within the development environment of the daytonaio/daytona project. This section focuses exclusively on the configuration relevant to development, omitting any aspects related to production settings.

Dockerfile Overview

A key component for Docker configuration in this project is the Dockerfile. Below is the configuration defined therein.

FROM ubuntu:22.04

RUN apt update -y && \
    apt install curl libgit2-1.1 -y

USER daytona

ENTRYPOINT ["sudo", "dockerd"]

Details of the Dockerfile:

1. Base Image:

   • The Docker image starts from ubuntu:22.04, which is a widely used base image suitable for various applications.

2. Installing Dependencies:

   • The RUN command updates the package list and installs necessary packages:
     • curl: A command-line tool for transferring data with URLs.
     • libgit2-1.1: A C library providing a linkable interface to interact with Git repositories.

3. User Setup:

   • The image runs under a non-root user named daytona, which enhances security.

4. Entrypoint:

   • The application is set to run the Docker daemon (dockerd) as the entry point. The use of sudo indicates that the daytona user has been granted permissions to execute this command.

Development Environment Configuration

To effectively use Docker for development, follow these steps:

Step 1: Building the Docker Image

To build the Docker image, navigate to your project directory that contains the Dockerfile and run the following command:

docker build -t daytona .

This command instructs Docker to build an image named daytona based on the Dockerfile in the current directory.

Step 2: Running the Docker Container

Once the image is built, you can run a container from this image:

docker run -it --rm --user daytona daytona

• The -it flag allows you to interact with the container’s terminal.
• The --rm flag ensures that the container is removed after it is stopped to keep the environment clean.
• The --user daytona flag runs the container as the daytona user.

Code Build with Go

In the context of the daytonaio/daytona, the Go instruction logic needs to center around the module name since the Go build output is influenced by the module name github.com/daytonaio/daytona. When building the Go application inside the Docker container, use the following command:

go build -o daytona github.com/daytonaio/daytona

This command compiles the Go source code and generates an executable named daytona.

Running Tests in the Dockerized Environment

When executing tests within the Docker container, it is important to remember the build constraint defined for testing. Specifically, this configuration must be acknowledged when initializing test execution. Execute the tests using:

go test -tags testing ./...

This command runs the tests in the current package and its sub-packages, honoring the build constraints that specify which files should be included.

Conclusion

Utilizing Docker within the development environment of daytonaio/daytona allows for a modular and replicable setup that can streamline development efforts. By utilizing the provided commands and configurations, developers can effectively engage with the codebase in a consistent environment.

Source: Original project Dockerfile provided above.