JupiterOne Starbase

repository·main·Indexed 18 days ago

https://github.com/jupiterone/starbase

An orchestrator for JupiterOne open source ingestion projects that aggregates assets and relationships from cloud, SaaS, and security services into a unified graph database powered by Neo4j. It supports over 115 open-source graph integrations, including Azure, GitHub, and Google Cloud. Starbase provides a CLI for managing the lifecycle of these integrations and supports storage endpoints for both local Neo4j instances and remote JupiterOne accounts.

Tokens
42.2K
Snippets
29
Records
52
Agent score
62%

What's inside Starbase

  1. Overview of Google Cloud integration for JupiterOne

    main
    The Google Cloud integration allows you to ingest Google Cloud resources and users into the JupiterOne graph. This enables resource visualization, mapping Google users to employees, and monitoring environment governance through pre-built queries, compliance frameworks (like Google Cloud CIS), and alert rule packs.
  2. Overview of Starbase

    main

    Starbase is a platform from JupiterOne designed to democratize graph-based security analysis. It collects assets and relationships from various services and systems—including cloud infrastructure, SaaS applications, and security controls—and aggregates them into an intuitive graph view. The underlying storage engine is powered by Neo4j.

    Key value propositions include:

    • Depth and breadth: Provides thousands of entities (vertices) and relationships (edges) out-of-the-box from a wide range of external services.
    • Uniform data model: Automatically classifies collected data, enabling the development of generic queries across different data sources.
    • Extensibility: Designed to allow for easy development of new graph integrations.
  3. Explore Starbase integrations

    main

    Starbase supports integrations with hundreds of services and systems. You can find detailed setup guides and configuration instructions for specific providers in their respective documentation pages.

    Key integration highlights include:

    • Cloud Providers: Azure, Google Cloud
    • Version Control: GitHub, Bitbucket
    • Productivity & Collaboration: Google Workspace, Jira
  4. Understand the Starbase architecture

    main

    Starbase is composed of three distinct layers:

    1. Starbase Core: The orchestration engine responsible for bootstrapping and managing the lifecycle of graph integrations.
    2. Graph Integrations: Individual tools that perform the actual data collection from third-party services (e.g., Google Cloud, AWS). These are managed as separate repositories.
    3. Graph Integrations SDK: A library containing core utilities and runtime packages used by developers to build new integrations.
  5. How the Google Cloud integration works

    main

    The integration operates on a periodic fetch cycle:

    1. JupiterOne periodically fetches users and cloud resources from your Google Cloud environment.
    2. This data is used to update the JupiterOne graph.
    3. You can then use JupiterOne queries to monitor updates or configure alerts to trigger actions when the graph changes.
  6. Uninstall the Google Cloud integration from JupiterOne

    main

    To remove the Google Cloud integration, follow these steps within the JupiterOne interface:

    1. Click the Gear Icon in the configuration menu and select Integrations.
    2. Locate the Google Cloud integration tile and click it.
    3. Find the specific integration to delete in the list.
    4. Click the trash can icon associated with that integration.
    5. Click the Remove button to confirm deletion.
  7. Configure Starbase via config.yaml

    main

    Starbase uses a config.yaml file located at the project root to manage integrations and storage settings.

    1. Create your configuration file by copying the example:
      cp config.yaml.example config.yaml
    2. Edit config.yaml to provide values for each integration and your storage engine.

    Note on Integrations: The specific configuration keys for individual integrations (e.g., PROJECT_ID, SERVICE_ACCOUNT_KEY_FILE) are defined within their respective graph-* repository projects. You must supply these values in the config.integrations[].config section.

    integrations:
      - name: graph-google-cloud
        instanceId: testInstanceId
        directory: ./.integrations/graph-google-cloud
        gitRemoteUrl: https://github.com/JupiterOne/graph-google-cloud.git
        config:
          SERVICE_ACCOUNT_KEY_FILE: {}
          PROJECT_ID: '...'
          ORGANIZATION_ID: '...'
          CONFIGURE_ORGANIZATION_PROJECTS: false
    storage:
      engine: neo4j
      config:
        username: neo4j
        password: devpass
        uri: bolt://localhost:7687
  8. Set up Google Cloud Organization auto-discovery

    main

    JupiterOne can automatically discover and configure integration instances for every project under a Google Cloud organization.

    Setup Steps

    1. Prepare a Main Project:
      • Create a service account in a single Google Cloud project.
      • Copy the service account email and generate a service account key.
      • Enable all required Service APIs in this 'main' project and all 'child' projects (except cloudasset.googleapis.com and iam.googleapis.com, which only need to be enabled in the 'main' project).
    2. Configure Organization Permissions:
      • Create a custom role at the Organization level with these permissions:
        resourcemanager.folders.get
        resourcemanager.folders.list
        resourcemanager.organizations.get
        resourcemanager.projects.get
        resourcemanager.projects.list
        serviceusage.services.list
        resourcemanager.organizations.getIamPolicy
        cloudasset.assets.searchAllIamPolicies
        orgpolicy.policy.get
      • Add the service account email as a member of the Organization. Assign it the custom role created above plus roles/iam.securityReviewer.
    3. Configure in JupiterOne:
      • Navigate to the Google Cloud integration configuration page.
      • Use the service account key from step 1.
      • Check Configure Organization Projects.
      • Enter your numerical Organization ID.
      • Click CREATE CONFIGURATION.

    Note: Auto-configuration may take several minutes. Once complete, individual project instances will appear in your integration list.

  9. Prerequisites for Starbase development

    main

    To develop with or run Starbase locally, ensure you have the following installed:

    1. Node.js: Use the official installer or a version manager like nvm or fnm.
    2. Yarn: The project uses yarn for dependency management.
    3. API Credentials: You must register accounts in the external systems you intend to ingest and obtain the necessary API credentials.

    After installation, run yarn install to set up the local environment.

    yarn install
  10. Enable required Google Cloud Service APIs

    main

    The JupiterOne Google Cloud integration requires specific APIs to be enabled to ingest data. If an API is disabled, the integration will skip that specific data type.

    Enabling via Google Cloud Console

    1. Click the service name link in the reference table below.
    2. Select your Google Cloud project from the dropdown.
    3. Click Enable.

    Enabling via gcloud CLI

    You can enable all supported services using the gcloud services enable command. Note: You can only enable 20 services at a time.

    gcloud services enable \
      accesscontextmanager.googleapis.com \
      apigateway.googleapis.com \
      appengine.googleapis.com \
      bigquery.googleapis.com \
      binaryauthorization.googleapis.com \
      privateca.googleapis.com \
      cloudasset.googleapis.com \
      dns.googleapis.com \
      cloudfunctions.googleapis.com \
      cloudkms.googleapis.com \
      logging.googleapis.com \
      memcache.googleapis.com \
      pubsub.googleapis.com \
      cloudresourcemanager.googleapis.com \
      run.googleapis.com \
      spanner.googleapis.com \
      sqladmin.googleapis.com \
      storage.googleapis.com \
      compute.googleapis.com \
      redis.googleapis.com \
      iam.googleapis.com \
      container.googleapis.com \
      serviceusage.googleapis.com \
      monitoring.googleapis.com
  11. Configure the Azure Integration in JupiterOne

    main

    Once Azure is prepared, add the configuration in the JupiterOne UI:

    1. In JupiterOne, go to the Gear Icon -> Integrations.
    2. Select the Azure tile and click Add Configuration.
    3. Fill in the following settings:
      • Account Name: A unique identifier for this account. If Tag with Account Name is checked, this value is stored in tag.AccountName.
      • Description: A description for your team.
      • Polling Interval: Frequency of updates (use DISABLED for manual execution).
      • Directory (tenant) ID: The Azure Tenant ID.
      • Application (client) ID: The Azure App Registration Client ID.
      • Application (client) Secret: The Azure App Registration Secret Value.
      • Ingest Active Directory: Enable this to ingest azure_user, azure_user_group, and azure_service_principal entities. (Enable in only one instance per Directory).
      • Scope Configuration:
        • To ingest all subscriptions: Select Configure Subscription Instances. This enables azure_management_group ingestion and automatically provisions instances for each subscription.
        • To ingest a single subscription: Enter the specific Subscription ID.
  12. Use the Starbase base container image

    main

    A pre-built base container image is available via the GitHub Container Registry.

    This image contains the Starbase installation but does not include any configuration or graph integrations. To use this image, you must:

    1. Provide configuration: Make your config.yaml available to the container (for example, using a Kubernetes ConfigMap).
    2. Initialize integrations: Run starbase setup inside the container to install the specific graph integrations required by your configuration before attempting to run data collection.