> ## Documentation Index
> Fetch the complete documentation index at: https://grandcentral.backbase.io/llms.txt
> Use this file to discover all available pages before exploring further.

# Get started

> Create your first custom connector for the Grand Central integration platform.

This section helps you create your first custom connector for the Grand Central integration platform.

## Overview

Custom connectors integrate your applications and services with the Grand Central integration platform. You build connectors with Apache Camel-K, and they run on Kubernetes to provide a scalable and reliable integration solution.

## Quick links

**Platform access:**

* [Azure Portal](https://portal.azure.com) - Access Azure resources and runtimes
* GitHub organization - Your installation-specific organization at `https://github.com/bb-ecos-{installation}`. Your Backbase onboarding team or project manager provides the exact URL.
* [Support Portal](https://gc-support.zendesk.com/hc/en-us) - Create tickets and get help

**Monitoring and observability:**

* [DataDog](https://gc-ecos.datadoghq.eu) - Application monitoring and logs
* [Grafana](https://ecosecos.grafana.net) - Metrics and dashboards

**Development tools:**

* [Maven Central](https://search.maven.org/) - Find Maven dependencies
* [Apache Camel components](https://camel.apache.org/components/4.8.x/index.html) - Available Camel components
* [Java documentation](https://docs.oracle.com/javase/11/docs/api/) - Java 11 API reference

## Before you start checklist

Before creating your first connector, ensure:

* You have access to the [self-service repository](https://github.com/bb-ecos-ecos/gc-devhub-ecos-self-service). This is the source of truth for building Custom Connectors.
* Your GitHub account is connected to the organization
* You've installed Java JDK 11+, Maven 3.6+, and Git
* You understand basic Git workflows (clone, branch, commit, PR)
* You have a clear understanding of the integration you want to build
* You know which external APIs/services you'll be integrating with
* (Optional) You have Azure access if you need to deploy to runtimes
* (Optional) You have DataDog/Grafana access if you need to monitor

**Need help with any of these?** See the [Learning Resources](#learning-resources) section below.

## Prerequisites

Before you begin, ensure you have:

* **Access to the self-service repository** - You need to be added as a team member with appropriate permissions
  * If you don't have access, contact your Backbase Onboarding team or project manager to request access
  * Manage access through the `team_members` section in `self-service.tfvars`
  * For additional user seats, create a [support ticket](https://gc-support.zendesk.com/hc/en-us)
* **GitHub account** - Connected to the organization
  * Your GitHub account must be part of the organization
  * Learn more about [GitHub workflows](https://docs.github.com/en/get-started/quickstart/github-flow) and [pull requests](https://docs.github.com/en/pull-requests/collaborating-with-pull-requests)
* **Azure access** (optional) - For runtime access to dev, staging, test, or UAT environments
  * Required if you need to deploy or monitor connectors in runtime environments
  * Grand Central roles in `self-service.tfvars` grant this access
* **Basic understanding** of:
  * **Git and GitHub workflows** - [Git documentation](https://git-scm.com/doc) | [GitHub Guides](https://guides.github.com/)
  * **Integration patterns** - Familiarity with common integration patterns (request/response, pub/sub, etc.)
  * **REST APIs** - Understanding of REST principles and HTTP methods
  * **Apache Camel** (recommended) - Basic knowledge of [Apache Camel](https://camel.apache.org/manual/) and route definitions

<Note>
  **Don't have access yet?** Contact your Backbase onboarding team or project manager to request access to the self-service repository. They can add you to the `team_members` section in `self-service.tfvars`.
</Note>

## Learning resources

If you need to brush up on any prerequisites:

* **Git and GitHub**: [GitHub Learning Lab](https://lab.github.com/) | [Atlassian Git Tutorial](https://www.atlassian.com/git/tutorials)
* **REST APIs**: [REST API Tutorial](https://restfulapi.net/) | [HTTP Methods Guide](https://developer.mozilla.org/en-US/docs/Web/HTTP/Methods)
* **Apache Camel**: [Camel Documentation](https://camel.apache.org/manual/) | [Camel Examples](https://github.com/apache/camel-examples)
* **Integration Patterns**: [Enterprise Integration Patterns](https://www.enterpriseintegrationpatterns.com/)
* README.md inside the [self-service repository](https://github.com/bb-ecos-ecos/gc-devhub-ecos-self-service)

## Your first connector

Follow these steps to create your first connector repository.

### Request repository creation

To create a new connector, you need to request a repository through the self-service process:

1. Navigate to the [self-service repository](https://github.com/bb-ecos-ecos/gc-devhub-ecos-self-service) and create a new branch.
2. Edit `self-service.tfvars` to add your connector repository definition.
3. Create a pull request targeting the `main` branch.

### Define your connector repository

Add your connector definition to the `repositories` section in `self-service.tfvars`:

```hcl theme={"system"}
repositories = {
  "my-custom-connector" = {
    repository_topics = [
      "grandcentral",
      "connector",
      "integration",
      "camel-k"
    ]
    enable_branch_protection = true
    enforce_admins = true
    default_branch = "develop"
    require_branch_up_to_date = true
    protected_branches = ["main", "develop"]
    required_status_checks = ["Validate pull request / Verify Maven project"]
    repository_init_from_zip = {
      name    = "grandcentral-connector-template"
      version = "2.0.5"
    }
    repository_visibility = "private"
  }
}
```

**Key configuration options:**

* **`repository_init_from_zip`**: Automatically initializes your repository from the connector template
  * `name`: Use `"grandcentral-connector-template"` for connector projects
  * `version`: Specify the template version (check for the latest available version)
* **`repository_topics`**: Add relevant tags for discoverability
* **`protected_branches`**: Branches that require pull request reviews before merging
* **`required_status_checks`**: CI/CD checks that must pass before merging

### Wait for repository provisioning

After you merge the pull request:

1. The pipeline automatically provisions your repository.
2. The pipeline initializes the repository from the connector template.
3. You receive access to the repository based on your team permissions.

### Clone and explore

Once your repository is created:

```bash theme={"system"}
git clone <your-organization>/my-custom-connector.git
cd my-custom-connector
```

The template includes:

* **Maven project structure** - Standard Java/Maven setup
* **Camel-K integration routes** - Pre-configured integration patterns
* **CI/CD pipelines** - Automated build and validation
* **Documentation templates** - README and configuration guides

## Understanding the template structure

The connector template provides a solid foundation:

```
my-custom-connector/
├── src/
│   └── main/
│       └── resources/
│           └── application.properties  # Configuration
│           └── routes/                # Camel routes
├── pom.xml                            # Maven dependencies
├── README.md                          # Project documentation
└── .github/
    └── workflows/                     # CI/CD pipelines
```

### About the connector template

The connector template (`grandcentral-connector-template`) provides:

* Pre-configured Apache Maven project structure
* Sample Apache Camel routes and integration patterns
* CI/CD pipeline configuration
* Health check endpoints
* Logging configuration

**Template versions:**

* Check the version used by existing connector repositories in your installation, and align with your team's choice.
* The repository is initialized from the template automatically when it is created.

## Next steps

Now that you have your connector repository set up:

1. **Review the template code** - Understand the structure and patterns
2. **Read the Build guide** - Learn how to develop and build your connector
3. **Configure your integration** - Define your API endpoints and data mappings
4. **Test locally** - Use the development tools to test your connector

## Getting help

* **Support Portal**: [Create a support ticket](https://support.backbase.com/) for access requests or platform issues
* **Documentation**: Check the Build, Run, and Monitor guides for detailed information
* **Team Support**: Contact the team or project manager onboarding you.
* **GitHub Issues**: Use the repository's issue tracker for technical questions

## Common first steps

After creating your connector repository, you may need to configure team access.

### Adding team members

If you need to add team members to work on your connector, add them to the `team_members` section in `self-service.tfvars`:

```hcl theme={"system"}
team_members = {
  "developer@example.com" = {
    github = {
      github_teams = ["development", "applications-live"]
    }
    grandcentral = {
      roles = ["dev-rw", "dev-ro"]
    }
  }
}
```

### Understanding access levels

* **GitHub teams**: Control repository access
  * `development`: Write access to development repositories
  * `applications-live`: Write access to applications-live repository
  * `self-service`: Can approve PRs in self-service repository
* **Grand Central roles**: Control runtime access
  * `dev-rw`: Full access to dev runtime
  * `dev-ro`: Read-only access to dev runtime
  * Similar roles available for `stg`, `test`, and `uat` environments