> ## Documentation Index
> Fetch the complete documentation index at: https://www.ravion.com/docs/llms.txt
> Use this file to discover all available pages before exploring further.

# Get an App Cluster's router

> Retrieve an App Cluster's router: whether the platform keeps it in service and the instances it runs. GET /apps/clusters/{moduleInstanceId}/router in the…



## OpenAPI

````yaml https://api.ravion.com/openapi.yaml get /apps/clusters/{moduleInstanceId}/router
openapi: 3.0.0
info:
  title: Ravion
  version: 0.0.0
servers:
  - url: https://api.ravion.com
security:
  - BearerAuth: []
tags:
  - name: Projects
  - name: Environments
  - name: FeatureFlags
  - name: Pipelines
  - name: PipelineRuns
  - name: TerraformResources
  - name: TerraformExecutionSummaries
  - name: PipelineStepExecutions
  - name: AwsCloudWatch
  - name: AwsAmp
  - name: PipelineVersions
  - name: Organizations
  - name: Stacks
  - name: StackWorkspaces
  - name: Auth
  - name: OAuth
  - name: User
  - name: Health
  - name: Memberships
  - name: ServiceAccounts
  - name: Integrations
  - name: AwsDefaultNetworks
  - name: AwsAccounts
  - name: ApiKeys
  - name: EksPrometheus
  - name: EksLoki
  - name: ExecutionEnvironments
  - name: ModuleDefinitions
  - name: ModuleCategories
  - name: ModuleVersions
  - name: ModuleInstances
  - name: DefaultValueDefinitions
  - name: DefaultValues
  - name: CodeSources
  - name: Github
  - name: GitHub Actions
  - name: Alerts
  - name: Gitlab
  - name: Slack
  - name: Git
  - name: MergeQueues
  - name: Values
  - name: Deployments
  - name: DeploymentResources
  - name: InfrastructureEvents
  - name: WebSocket
  - name: Domains
  - name: AcmCertificates
  - name: NotificationDestinations
  - name: NotificationDispatches
  - name: NotificationEvents
  - name: NotificationRules
  - name: Activity
  - name: Describe
  - name: Reports
  - name: BillingPlans
  - name: BillingAccounts
  - name: BillingCycles
  - name: BillingUsageSummaries
  - name: BillingAddOns
  - name: BillingInvoices
  - name: Authorization
  - name: Sandboxes
  - name: SandboxCommands
  - name: SandboxPorts
  - name: Apps
paths:
  /apps/clusters/{moduleInstanceId}/router:
    get:
      tags:
        - Apps
      summary: Get an App Cluster's router
      description: >-
        Retrieve an App Cluster's router: whether the platform keeps it in
        service and the instances it runs. You need permission to update the App
        Cluster's module instance. Returns 404 when the App Cluster does not
        exist or you cannot update it, and 422 when the module instance is not
        an App Cluster.
      operationId: GetAppClusterRouter
      parameters:
        - description: App Cluster module instance (`minst_*`).
          in: path
          name: moduleInstanceId
          required: true
          schema:
            type: string
      responses:
        '200':
          content:
            application/json:
              schema:
                additionalProperties: false
                properties:
                  data:
                    $ref: '#/components/schemas/AppClusterRouter'
                required:
                  - data
                type: object
          description: The request has succeeded.
        '400':
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/Errors.UserFacingErrorData'
          description: The request is invalid or malformed.
        '401':
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/Errors.UserFacingErrorData'
          description: You are not authenticated
        '403':
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/Errors.UserFacingErrorData'
          description: You do not have permission to access this resource.
        '404':
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/Errors.UserFacingErrorData'
          description: The server cannot find the requested resource.
        '422':
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/Errors.UserFacingErrorData'
          description: Client error
        '500':
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/Errors.UserFacingErrorData'
          description: Server error
components:
  schemas:
    AppClusterRouter:
      additionalProperties: false
      description: >-
        An App Cluster's router: the instances that receive the requests to the
        App Cluster's apps from its load balancer and send each one to its app's
        sandbox, waking a paused app first.
      properties:
        desired:
          allOf:
            - $ref: '#/components/schemas/AppClusterRouterDesired'
          description: >-
            Whether the platform keeps the router in service. Stopping or
            starting the router changes it at once; the instances follow within
            minutes.
        instances:
          description: >-
            The router's instances that have been launched and not yet
            terminated, oldest first.
          items:
            $ref: '#/components/schemas/AppClusterRouterInstance'
          type: array
        servingInstanceId:
          description: >-
            EC2 instance id of the instance behind the App Cluster's load
            balancer. Absent while none is.
          type: string
        status:
          allOf:
            - $ref: '#/components/schemas/AppClusterRouterStatus'
          description: >-
            Where the router is: `RUNNING` when it is started and one of its
            instances is ready and not draining, `STARTING` when it is started
            and none is, `STOPPING` when it is stopped and an instance remains,
            `STOPPED` when it is stopped and none remains.
      required:
        - status
        - desired
        - instances
      type: object
    Errors.UserFacingErrorData:
      additionalProperties: false
      description: |-
        User-facing error presentation data.
        This is what the API returns to the frontend after formatting ErrorData
        using CEL templates from the error registry.

        Used for both:
        - Error fields on domain models (e.g., PipelineRun.error)
        - API error response bodies (HTTP 4xx/5xx responses)
      properties:
        action:
          allOf:
            - $ref: '#/components/schemas/Errors.Action'
          description: Optional action to help resolve the error
        code:
          description: Full error code, e.g., "Ravion:Pipeline:NOT_FOUND"
          type: string
        description:
          description: Additional description with more details
          type: string
        details:
          description: Structured details rendered as user-facing sections.
          items:
            $ref: '#/components/schemas/Errors.UserFacingErrorDetailSection'
          type: array
        isInternal:
          description: >-
            Indicates whether this error is internal (only set when
            ShowInternal=true).

            This allows SUPERADMINs to identify internal errors while viewing
            full details.
          type: boolean
        message:
          description: Main error message (required)
          type: string
        metadata:
          additionalProperties: {}
          description: >-
            Error params/metadata. Stripped for internal errors unless
            superadmin.
          type: object
        requestId:
          description: Request ID for correlating errors with server logs.
          type: string
      required:
        - code
        - message
      type: object
    AppClusterRouterDesired:
      description: >-
        Whether the platform keeps an App Cluster's router in service.


        `RUNNING`: a router instance serves the App Cluster's apps, and a new
        one replaces it when it stops

        answering or a new router release comes out. `STOPPED`: no router
        instance runs, so no app of the App

        Cluster is reachable at its URLs, until the router is started again. A
        router that has never been

        started, because its App Cluster has not finished its first stack run,
        is `STOPPED`.
      enum:
        - RUNNING
        - STOPPED
      type: string
    AppClusterRouterInstance:
      additionalProperties: false
      description: >-
        One EC2 instance of an App Cluster's router. While one instance replaces
        another, both are listed.
      properties:
        connected:
          description: >-
            True while the instance is connected to Ravion and receives every
            change to the App Cluster's routes.
          type: boolean
        draining:
          description: >-
            True once the instance is being taken out of service: it has been
            removed from the App Cluster's load balancer and finishes the
            requests it holds before it is terminated.
          type: boolean
        imageId:
          description: AMI the instance was launched from.
          type: string
        instanceId:
          description: >-
            EC2 instance id of the router instance, in the App Cluster's AWS
            account.
          type: string
        launchedAt:
          allOf:
            - $ref: '#/components/schemas/UtcDateTime'
          description: When the instance was launched.
        ready:
          description: >-
            True while the instance is connected to Ravion and has loaded the
            route of every app of the App Cluster. Only a ready instance is put
            behind the App Cluster's load balancer.
          type: boolean
        release:
          description: Router release the instance runs.
          type: string
      required:
        - instanceId
        - ready
        - connected
        - draining
        - release
        - imageId
        - launchedAt
      type: object
    AppClusterRouterStatus:
      description: >-
        Where an App Cluster's router is, as its start and stop button shows it.


        `RUNNING`: a ready router instance serves the App Cluster's apps.
        `STARTING`: the router is started but no instance

        is ready yet; it is being launched, or launched again after a failure.
        `STOPPING`: the router is stopped and its

        instances are being taken out of service. `STOPPED`: no router instance
        runs.
      enum:
        - RUNNING
        - STARTING
        - STOPPING
        - STOPPED
      type: string
    Errors.Action:
      additionalProperties: false
      description: Action to help user resolve the error
      properties:
        label:
          description: Button/link label text
          type: string
        url:
          description: URL to navigate to for resolution
          type: string
      required:
        - label
        - url
      type: object
    Errors.UserFacingErrorDetailSection:
      additionalProperties: false
      description: Structured user-facing error detail section.
      properties:
        items:
          description: List of detail values for this section.
          items:
            type: string
          type: array
        object:
          additionalProperties: {}
          description: Structured detail payload for object rendering.
          type: object
        render:
          description: Rendering hint for clients. Valid values are list or object.
          type: string
        title:
          description: Detail section title shown in the UI.
          type: string
      required:
        - title
        - render
      type: object
    UtcDateTime:
      description: UTC RFC3339 timestamp with a required Z suffix
      format: date-time
      pattern: ^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(\.\d{1,9})?Z$
      type: string
      x-go-type: apitypes.UTCDateTime
      x-go-type-import:
        name: apitypes
        path: ravion/api-go/pkg/apitypes
  securitySchemes:
    BearerAuth:
      scheme: Bearer
      type: http

````

This documentation is built and hosted on [Mintlify](https://mintlify.com), a developer documentation platform.