CI/CD Integration

Daytona can be integrated with CI/CD pipelines for seamless development workflows.

Example:

# This is a simple example of how to use Daytona in a CI/CD pipeline. 
          # For a complete example of how Daytona can be integrated into a CI/CD pipeline, please refer to the documentation at https://github.com/daytonaio/daytona/. 
          
          # Define a build stage for creating a workspace
          build:
            stage: build
            image: daytonaio/daytona:latest 
            script:
              - daytona create https://github.com/daytonaio/daytona --name my-workspace --target local --branch main  
              - daytona start my-workspace  
              - daytona code my-workspace --ide vscode
          
          # Define a test stage for running tests within the workspace
          test:
            stage: test
            image: daytonaio/daytona:latest
            script:
              - daytona ssh my-workspace
              - npm install
              - npm test
          
          # Define a deploy stage for deploying to production
          deploy:
            stage: deploy
            image: daytonaio/daytona:latest
            script:
              - echo "Deploying to production"
              - daytona stop my-workspace
          

Explanation

1. Create a Workspace: The daytona create command is used to create a workspace for your project. The command accepts various flags to customize the creation process, for example:

   • --name: Specify the name of your workspace.
   • --target: Specify the target of your workspace (e.g., ‘local’ for local development).
   • --branch: Specify the Git branch to use in your project.
   • --ide: Specify the IDE you want to use (e.g., ‘vscode’).
   • --builder: Specify the builder (e.g., ‘devcontainer’).
   • --custom-image: Create the project with a custom image.
   • --custom-image-user: Specify the user for the custom image.

2. Start the Workspace: The daytona start command will start the workspace and make it available for development.

3. Open the Workspace in IDE: The daytona code command will open the workspace in your preferred IDE (e.g., VSCode).

4. SSH into the Workspace: The daytona ssh command will allow you to securely access the workspace through SSH.

5. Run Tests: You can use your CI/CD pipeline to run tests within the workspace using the appropriate commands.

6. Deploy to Production: You can use your CI/CD pipeline to deploy your project to production once tests are successful.

Resources

• Daytona Documentation: https://github.com/daytonaio/daytona/
• Daytona CLI Reference: docs/daytona_create.md
• Daytona CLI Reference: docs/daytona.md
• Daytona CLI Reference: docs/workspace_mode/daytona.md
• Daytona CLI Reference: docs/daytona_project-config_add.md
• Daytona CLI Reference: docs/workspace_mode/daytona_forward.md
• Daytona CLI Reference: docs/daytona_git-providers_add.md
• Daytona CLI Reference: docs/daytona_server.md
• Daytona CLI Reference: docs/daytona_code.md
• Daytona CLI Reference: docs/workspace_mode/daytona_agent.md

Code

• Daytona CLI Configuration: hack/docs/daytona_create.yaml
• Daytona Dev Container Configuration: .devcontainer/devcontainer.json
• Daytona CLI Core Code: pkg/cmd/cmd.go
• Daytona Agent Code: pkg/cmd/agent/agent.go
• Daytona Workspace Creation Code: pkg/cmd/workspace/create.go
• Daytona CLI Configuration: hack/docs/daytona.yaml
• Daytona CLI IDE Integration Code: pkg/cmd/ide.go
• Daytona CLI Documentation Generation Code: pkg/cmd/generatedocs.go
• Daytona Provisioner Interface: pkg/provisioner/provisioner.go
• Daytona Builder Image Dev Container Configuration: hack/builder_image/.devcontainer/devcontainer.json
• Daytona CLI Workspace IDE Integration Code: pkg/cmd/workspace/code.go

Top-Level Directory Explanations

.devcontainer/ - Contains development container related configurations for Visual Studio Code.

cmd/ - Contains command-line interface tools and scripts.

cmd/daytona/ - Subdirectory for Daytona-specific command-line tools.

cmd/daytona/config/ - Subdirectory for configuration files for Daytona command-line tools.

hack/ - Directory for Go development, including build scripts and dependencies.

hack/builder_image/ - Subdirectory for building Docker images for Go development.

hack/project_image/ - Subdirectory for building the project Docker image.

internal/ - Private package directory for the project’s internal modules.

internal/cmd/ - Subdirectory for command-line tools.

internal/cmd/tailscale/ - Subdirectory for Tailscale command-line tools.

internal/testing/ - Subdirectory for testing-related modules.

internal/testing/agent/ - Subdirectory for testing agents.

internal/testing/server/ - Subdirectory for testing server configurations.

internal/util/ - Subdirectory for utility modules.

pkg/ - Go packages directory.

pkg/api/ - Subdirectory for API-related packages.

pkg/api/controllers/ - Subdirectory for API controller handlers.

pkg/cmd/ - Subdirectory for command-line interface tools.

pkg/cmd/agent/ - Subdirectory for agent command-line tools.

pkg/cmd/profiledata/ - Subdirectory for profiledata command-line tools.

pkg/cmd/target/ - Subdirectory for target command-line tools.

pkg/db/ - Subdirectory for database-related packages and scripts.

pkg/db/dto/ - Subdirectory for database data transfer objects.

pkg/gitprovider/ - Subdirectory for Git provider package.

pkg/server/ - Subdirectory for server-related packages and scripts.

pkg/server/projectconfig/ - Subdirectory for project configuration server-side.

Entrypoints and Where to Start

cmd/daytona/main.go - This is the main entrypoint of the Daytona application. The ‘main’ function initializes the application and starts the server. The ‘init’ function is used for initialization tasks such as setting up logging and loading configuration files.