Konfigurieren einer Landscape

run:
  my-service:
    # Only mounts /home/user/app/uploads
    volumeMounts:
      - name: _workspace
        mountPath: /home/user/app
        workspacePath: uploads
    steps:
      - name: Start Server
        command: npm start

run:
  api-server:
    plan: 21        # Resource tier (determines CPU/memory)
    replicas: 3     # Number of instances
    steps:
      - name: Start Server
        command: node server.js

run:
  backend:
    healthEndpoint: http://localhost:8080/health
    network:
      ports:
        - port: 8080
          isPublic: false
      paths:
        - port: 8080
          path: /api
    steps:
      - command: npm run start:backend

run:
  my-service:
    env:
      NODE_ENV: production
      SECRET_KEY: ${{ vault.secretFoo }}
      DB_PASSWORD: ${{ vault.dbPassword }}
      PG_USER: ${{ workspace.env['BACKEND_PG_USER'] }}

run:
  alpine-image:
    image: alpine:latest
    steps:
      - name: Run Alpine
        command: echo "Hello from Alpine!"
    plan: 21
    network:
      ports:
        - port: 80
          isPublic: false
      paths:
        - port: 80
          path: /
  nginx-server:
    image: nginx-unprivileged:1.25-alpine
    command: ["-g", "daemon off;"]
    plan: 21
    healthEndpoint: http://localhost/
    network:
      ports:
        - port: 80
          isPublic: false
      paths:
        - port: 80
          path: /
    env:
      NGINX_HOST: example.com
    volumeMounts:
      - name: _workspace
        mountPath: /etc/nginx/nginx.conf
        workspacePath: custom-nginx.conf
    runAsUser: 1000
    runAsGroup: 1000

prepare:
  steps:
    - name: Deploy Application
      command: |
        kubectl apply -f k8s/deployment.yaml
        kubectl apply -f k8s/service.yaml

prepare:
  steps:
    - name: Deploy with Helm
      command: |
        helm repo add corp42 https://charts.corp42.net
        helm repo update
        helm install my-release corp42/my-awesome-app -n app --create-namespace -f values-codesphere.yaml

# Example fixture for the current schema after the managed-service provider schemaVersion rename.
# `schemaVersion` pins the fixture to the current pipeline schema.
schemaVersion: v0.4

# `prepare` runs setup before tests and deploys.
prepare:
  # `steps` lists sequential setup commands.
  steps:
    # `name` is a descriptive label only.
    - name: Install dependencies
      # `command` is the shell command to execute.
      command: yarn install

# `test` runs verification commands after setup.
test:
  # `steps` keeps the same stage shape as `prepare`.
  steps:
    # `name` documents the test step.
    - name: Run unit tests
      # `command` runs the example test suite.
      command: yarn test --run

# `run` contains the named deploy targets for the workspace.
run:
  # Reactive runtime with the full set of supported server fields.
  reactive-app:
    # `steps` defines the lifecycle commands for a reactive runtime.
    steps:
      # Build the app before startup.
      - name: Build app
        # Produce deployable build output.
        command: yarn build
      # Start the application process.
      - name: Start app
        # Launch the runtime server.
        command: yarn start
    # `image` optionally customizes the reactive base image.
    image: ghcr.io/codesphere-cloud/example-reactive:latest
    # `healthEndpoint` is probed to determine readiness.
    healthEndpoint: http://127.0.0.1:3000/healthz/app
    # `plan` selects the workspace plan.
    plan: 20
    # `replicas` requests horizontal scaling.
    replicas: 2
    # `isPublic` is ignored when advanced `network` settings are present.
    isPublic: true
    # `network` defines exposed ports and routed paths.
    network:
      # `ports` exposes raw runtime ports.
      ports:
        # `port` is the runtime port number to expose.
        - port: 3000
          # `isPublic` makes the port reachable from outside the workspace.
          isPublic: true
        - port: 9229
          isPublic: false
      # `paths` maps HTTP prefixes onto runtime ports.
      paths:
        # Route the root path to port `3000`.
        - port: 3000
          path: /
          stripPath: false
        # Route `/api` to port `3000` and strip the prefix.
        - port: 3000
          path: /api
          stripPath: true
    # `env` injects runtime environment variables.
    env:
      # Example string env var.
      NODE_ENV: production
      # Example numeric env var.
      PORT: 3000
    # `runAsUser` sets the runtime UID.
    runAsUser: 1000
    # `runAsGroup` sets the runtime GID.
    runAsGroup: 1000
    # `volumeMounts` attaches workspace storage into the runtime.
    volumeMounts:
      # `name` selects the workspace volume.
      - name: _workspace
        # `mountPath` is the destination inside the runtime.
        mountPath: /home/user/app
        # `workspacePath` selects which subdirectory to mount.
        workspacePath: ""

  # Container runtime with the full set of supported server fields.
  container-app:
    # `image` is required for container runtimes.
    image: ghcr.io/codesphere-cloud/example-container:latest
    # `command` overrides the image entrypoint/command.
    command:
      # First argv entry.
      - node
      # Second argv entry.
      - server.js
    # The rest of the fields are shared with reactive runtimes.
    healthEndpoint: http://127.0.0.1:8080/healthz/app
    # `plan` selects the workspace plan.
    plan: 20
    # `replicas` requests horizontal scaling for this runtime.
    replicas: 1
    # `isPublic` allows the routed service to be reachable externally.
    isPublic: true
    # This simple network shape publishes one routed path.
    network:
      # `path` is the public prefix for this service.
      path: /container
      # `stripPath` controls whether the prefix is preserved upstream.
      stripPath: false
    env:
      # Example string env var.
      NODE_ENV: production
      # Example numeric env var.
      PORT: 8080
    # `runAsUser` sets the runtime UID.
    runAsUser: 1000
    # `runAsGroup` sets the runtime GID.
    runAsGroup: 1000
    # `volumeMounts` attaches workspace storage into the runtime.
    volumeMounts:
      # `name` selects the workspace volume.
      - name: _workspace
        # `mountPath` is the destination inside the runtime.
        mountPath: /home/user/app
        # `workspacePath` selects which subdirectory to mount.
        workspacePath: ""

  # Managed service runtime in v0.4:
  # - `provider.version` was renamed to `provider.schemaVersion`
  # This key names the managed service instance.
  postgres:
    # `provider` identifies the catalog entry to provision.
    provider:
      # `name` selects the managed service type.
      name: postgres
      # `schemaVersion` is the renamed provider version field in v0.4.
      schemaVersion: "14"
    # `plan` selects the service plan and sizing.
    plan:
      # `id` identifies the chosen catalog plan.
      id: 1
      # `parameters` contains provider-specific numeric options.
      parameters:
        # `storage` requests disk capacity.
        storage: 1024
        # `cpu` requests compute capacity.
        cpu: 1
        # `memory` requests RAM capacity.
        memory: 512
    # `config` contains non-secret provider configuration.
    config:
      # `database` is an example provider config key.
      database: app
      # `extensions` shows that lists are allowed in config payloads.
      extensions:
        - pgcrypto
    # `secrets` contains secret provider configuration.
    secrets:
      # `password` is an example secret key.
      password: secret

# Example fixture for the v0.2 -> v0.3 migration where workspace mounts become explicit.
# `schemaVersion` selects the v0.3 parser rules.
schemaVersion: v0.3

# `prepare` runs setup work before tests and deploys.
prepare:
  # `steps` lists the stage commands in execution order.
  steps:
    # `name` labels the step for humans.
    - name: Install dependencies
      # `command` is the shell command to run.
      command: yarn install

# `test` runs verification after `prepare`.
test:
  # `steps` keeps the same shape across all single-running stages.
  steps:
    # `name` documents the purpose of the test step.
    - name: Run unit tests
      # `command` runs the tests.
      command: yarn test --run

# `run` contains named deploy targets.
run:
  # v0.3 keeps the v0.2 deploy shapes, but makes workspace mounts explicit.
  reactive-app:
    # `steps` marks this target as a reactive runtime.
    steps:
      # Build before startup.
      - name: Build app
        # Produce the deployable app bundle.
        command: yarn build
      # Start the runtime process.
      - name: Start app
        # Launch the application server.
        command: yarn start
    # `image` optionally customizes the reactive base image.
    image: ghcr.io/codesphere-cloud/example-reactive:latest
    # `healthEndpoint` is polled after deployment.
    healthEndpoint: http://127.0.0.1:3000/healthz/app
    # `plan` selects the workspace plan for this runtime.
    plan: 20
    # `replicas` requests multiple runtime instances.
    replicas: 2
    # `isPublic` is ignored here because the advanced network shape is used below.
    isPublic: true
    # `network` configures public ports and HTTP routes.
    network:
      # `ports` exposes runtime ports directly.
      ports:
        # `port` is the runtime port number.
        - port: 3000
          # `isPublic` exposes this port externally.
          isPublic: true
        - port: 9229
          isPublic: false
      # `paths` maps HTTP routes to runtime ports.
      paths:
        # Route `/` to port `3000`.
        - port: 3000
          path: /
          stripPath: false
        # Route `/api` to the same port and strip the prefix.
        - port: 3000
          path: /api
          stripPath: true
    # `env` provides environment variables to the runtime.
    env:
      # String env var example.
      NODE_ENV: production
      # Numeric env var example.
      PORT: 3000
    # `runAsUser` sets the effective UID inside the runtime.
    runAsUser: 1000
    # `runAsGroup` sets the effective GID inside the runtime.
    runAsGroup: 1000
    # In v0.3 this commonly explicit mount becomes important.
    volumeMounts:
      # `name` refers to the workspace volume.
      - name: _workspace
        # `mountPath` is the in-container destination.
        mountPath: /home/user/app
        # `workspacePath` of `""` mounts the workspace root.
        workspacePath: ""

  # This target demonstrates the container-runtime branch of the schema.
  container-app:
    # `image` is the required runtime image.
    image: ghcr.io/codesphere-cloud/example-container:latest
    # `command` overrides the image startup command.
    command:
      # First argv segment.
      - node
      # Second argv segment.
      - server.js
    # Common deploy-server fields are shared with reactive runtimes.
    healthEndpoint: http://127.0.0.1:8080/healthz/app
    # `plan` selects the workspace plan for this runtime.
    plan: 20
    # `replicas` requests the instance count.
    replicas: 1
    # `isPublic` allows the simple network route to be exposed publicly.
    isPublic: true
    # This simple network shape publishes a single HTTP route.
    network:
      # `path` is the public route prefix.
      path: /container
      # `stripPath: false` forwards the full incoming path.
      stripPath: false
    env:
      # String env var example.
      NODE_ENV: production
      # Numeric env var example.
      PORT: 8080
    # `runAsUser` sets the effective UID inside the runtime.
    runAsUser: 1000
    # `runAsGroup` sets the effective GID inside the runtime.
    runAsGroup: 1000
    # `volumeMounts` makes the workspace available inside the container.
    volumeMounts:
      # `name` refers to the workspace volume.
      - name: _workspace
        # `mountPath` is the in-container destination.
        mountPath: /home/user/app
        # `workspacePath` of `""` mounts the workspace root.
        workspacePath: ""

  # Managed service runtime in v0.3 still uses `provider.version`.
  # This key names the service instance.
  postgres:
    # `provider` identifies the managed service type and version.
    provider:
      # `name` selects the provider implementation.
      name: postgres
      # `version` is still the field name before v0.4.
      version: "14"
    # `plan` chooses the service plan and parameters.
    plan:
      # `id` identifies the selected plan.
      id: 1
      # `parameters` carries provider-defined numeric sizing inputs.
      parameters:
        # `storage` requests persistent disk capacity.
        storage: 1024
        # `cpu` requests compute units for the service.
        cpu: 1
        # `memory` requests RAM for the service.
        memory: 512
    # `config` carries non-secret provider inputs.
    config:
      # `database` is a provider-defined config field.
      database: app
      # `extensions` shows that provider config can include lists.
      extensions:
        - pgcrypto
    # `secrets` carries sensitive provider inputs.
    secrets:
      # `password` is a provider-defined secret value.
      password: secret

# Example fixture for the first versioned pipeline schema with deploy runtimes.
# `schemaVersion` selects the parser rules for this fixture.
schemaVersion: v0.2

# `prepare` runs initial setup before tests and deployment.
prepare:
  # Steps are executed sequentially inside the stage.
  steps:
    # Step names are descriptive only.
    - name: Install dependencies
      # Commands contain the shell instruction to execute.
      command: yarn install

# `test` runs verification work after `prepare`.
test:
  # Test steps use the same stage shape as `prepare`.
  steps:
    # This name explains what the test step does.
    - name: Run unit tests
      # The command launches the test suite.
      command: yarn test --run

# `run` becomes a map of named deploy runtimes in v0.2.
run:
  # Reactive runtime:
  # - identified by `steps`
  # - may optionally set `image`
  # - all common deploy-server fields are supported
  # The map key names this deploy target.
  reactive-app:
    # `steps` marks this as a reactive runtime and defines its lifecycle commands.
    steps:
      # This step builds the app before it starts.
      - name: Build app
        # The build command prepares production assets.
        command: yarn build
      # This step names the runtime startup command.
      - name: Start app
        # The start command launches the reactive process.
        command: yarn start
    # Optional custom base image for reactive execution.
    image: ghcr.io/codesphere-cloud/example-reactive:latest
    # Optional health endpoint used by the platform.
    healthEndpoint: http://127.0.0.1:3000/healthz/app
    # Optional workspace plan id.
    plan: 20
    # Optional replica count.
    replicas: 2
    # `isPublic` is ignored when `network` uses the advanced shape.
    isPublic: true
    # Advanced network config:
    # - `ports` defines public/private TCP ports
    # - `paths` defines routed HTTP paths
    network:
      # `ports` exposes raw TCP ports on the runtime.
      ports:
        # `port` is the container port that the platform should expose.
        - port: 3000
          # `isPublic` controls whether the port is reachable externally.
          isPublic: true
        - port: 9229
          isPublic: false
      # `paths` configures HTTP routing rules on top of the ports.
      paths:
        # `port` selects which runtime port receives this HTTP path.
        - port: 3000
          # `path` is the incoming route prefix to match.
          path: /
          # `stripPath` controls whether the prefix is removed before proxying.
          stripPath: false
        - port: 3000
          path: /api
          stripPath: true
    # Environment values may be strings or numbers.
    env:
      # `NODE_ENV` is a representative string environment variable.
      NODE_ENV: production
      # `PORT` shows that numeric env values are accepted too.
      PORT: 3000
    # Optional user/group to run the process as.
    runAsUser: 1000
    # `runAsGroup` pairs with `runAsUser` for filesystem permissions.
    runAsGroup: 1000
    # Optional workspace mounts.
    volumeMounts:
      # `name` currently supports the workspace volume only.
      - name: _workspace
        # `mountPath` is where the workspace appears inside the runtime.
        mountPath: /home/user/app
        # `workspacePath` narrows the mounted subdirectory; empty means the root.
        workspacePath: ""

  # Container runtime:
  # - identified by `image`
  # - must not define `steps`
  # - may optionally set `command`
  # This second deploy target demonstrates the container-runtime shape.
  container-app:
    # `image` is required for container runtimes.
    image: ghcr.io/codesphere-cloud/example-container:latest
    # `command` overrides the image default entrypoint/command.
    command:
      # Command arrays are passed through as ordered argv segments.
      - node
      - server.js
    # The remaining fields share the common deploy-server schema.
    healthEndpoint: http://127.0.0.1:8080/healthz/app
    plan: 20
    replicas: 1
    isPublic: true
    # Simple network config routes one path to the main port.
    network:
      # `path` exposes the service under a single HTTP prefix.
      path: /container
      # `stripPath` keeps the `/container` prefix when forwarding requests.
      stripPath: false
    env:
      NODE_ENV: production
      PORT: 8080
    runAsUser: 1000
    runAsGroup: 1000
    volumeMounts:
      - name: _workspace
        mountPath: /home/user/app
        workspacePath: ""

  # Managed service runtime in v0.2:
  # - uses `provider.version`
  # This key names the managed service instance.
  postgres:
    # `provider` identifies which service catalog entry to provision.
    provider:
      # `name` selects the provider type.
      name: postgres
      # `version` selects the provider schema version in v0.2/v0.3.
      version: "14"
    # `plan` selects a service plan and its numeric parameters.
    plan:
      # `id` identifies the chosen plan in the marketplace catalog.
      id: 1
      # Provider-specific integer parameters.
      parameters:
        # `storage` requests persistent disk capacity.
        storage: 1024
        # `cpu` requests compute units for the service.
        cpu: 1
        # `memory` requests RAM for the service.
        memory: 512
    # Arbitrary provider config payload.
    config:
      # `database` is a provider-defined config field.
      database: app
      # `extensions` shows that provider config can include lists.
      extensions:
        - pgcrypto
    # Arbitrary provider secrets payload.
    secrets:
      # `password` is a provider-defined secret value.
      password: secret

# Example fixture for the legacy pre-versioned parser shape.
# v0.1 has no top-level schemaVersion field yet.
# All three top-level entries are plain stages, not deploy-runtime maps.

# `prepare` runs setup work before tests or app startup.
prepare:
  # Steps are executed sequentially.
  steps:
    # Step names are optional and only descriptive.
    - name: Install dependencies
      # Command is the only required field on a step.
      command: yarn install

# `test` runs verification commands after `prepare`.
test:
  # Test steps still use the same sequential stage shape as `prepare`.
  steps:
    # This label only helps readers identify the step in UIs or logs.
    - name: Run unit tests
      # The command contains the shell instruction to execute.
      command: yarn test --run

# `run` executes the main workload for this legacy schema version.
run:
  # In v0.1, `run` is still just a plain stage.
  # Deploy runtimes such as reactive servers, container runtimes,
  # and managed services are introduced in later versions.
  # The run stage can also define a health endpoint.
  healthEndpoint: http://127.0.0.1:3000/healthz/app
  # Runtime steps are executed in order, just like any other stage.
  steps:
    # The step name documents the intent of the runtime command.
    - name: Start dev server
      # The command starts the long-running application process.
      command: yarn start