url
stringlengths 24
122
| repo_url
stringlengths 60
156
| date_extracted
stringdate 2025-08-13 00:00:00
2025-08-13 00:00:00
| root
stringlengths 3
85
| breadcrumbs
listlengths 1
6
| filename
stringlengths 6
60
| stage
stringclasses 33
values | group
stringclasses 81
values | info
stringclasses 22
values | title
stringlengths 3
110
⌀ | description
stringlengths 11
359
⌀ | clean_text
stringlengths 47
3.32M
| rich_text
stringlengths 321
3.32M
|
|---|---|---|---|---|---|---|---|---|---|---|---|---|
https://docs.gitlab.com/topics/git/how_to_install_git
|
https://gitlab.com/gitlab-org/gitlab/-/tree/master/doc/topics/git/_index.md
|
2025-08-13
|
doc/topics/git/how_to_install_git
|
[
"doc",
"topics",
"git",
"how_to_install_git"
] |
_index.md
|
Create
|
Source Code
|
To determine the technical writer assigned to the Stage/Group associated with this page, see https://handbook.gitlab.com/handbook/product/ux/technical-writing/#assignments
|
Install Git
|
How to install Git on your local machine.
|
To contribute to GitLab projects, you must download, install, and configure the Git client on
your local machine. GitLab uses the SSH protocol to securely communicate with Git.
With SSH, you can authenticate to the GitLab remote server without entering your username
and password each time.
For information on downloading and installing Git on other operating systems, see the
[official Git website](https://git-scm.com/downloads).
After you install and configure Git, [generate and add an SSH key pair](../../../user/ssh.md#generate-an-ssh-key-pair)
to your GitLab account.
## Install and update Git
{{< tabs >}}
{{< tab title="macOS" >}}
Though a version of Git is supplied by macOS, you should install the latest version of Git. A common way to
install Git is with [Homebrew](https://brew.sh/index.html).
To install the latest version of Git on macOS with Homebrew:
1. If you've never installed Homebrew before, follow the
[Homebrew installation instructions](https://brew.sh/index.html).
1. In a terminal, install Git by running `brew install git`.
1. Verify that Git works on your local machine:
```shell
git --version
```
Keep Git up to date by periodically running the following command:
```shell
brew update && brew upgrade git
```
{{< /tab >}}
{{< tab title="Ubuntu Linux" >}}
Though a version of Git is supplied by Ubuntu, you should install the latest version of Git. The latest version is
available using a Personal Package Archive (PPA).
To install the latest version of Git on Ubuntu Linux with a PPA:
1. In a terminal, configure the required PPA, update the list of Ubuntu packages, and install `git`:
```shell
sudo apt-add-repository ppa:git-core/ppa
sudo apt-get update
sudo apt-get install git
```
1. Verify that Git works on your local machine:
```shell
git --version
```
Keep Git up to date by periodically running the following command:
```shell
sudo apt-get update && sudo apt-get install git
```
{{< /tab >}}
{{< /tabs >}}
## Configure Git
To start using Git from your local machine, you must enter your credentials
to identify yourself as the author of your work.
You can configure your Git identity locally or globally:
- Locally: Use for the current project only.
- Globally: Use for all current and future projects.
{{< tabs >}}
{{< tab title="Local setup" >}}
Configure your Git identity locally to use it for the current project only.
The full name and email address should match the ones you use in GitLab.
1. In your terminal, add your full name. For example:
```shell
git config --local user.name "Alex Smith"
```
1. Add your email address. For example:
```shell
git config --local user.email "your_email_address@example.com"
```
1. To check the configuration, run:
```shell
git config --local --list
```
{{< /tab >}}
{{< tab title="Global setup" >}}
Configure your Git identity globally to use it for all current and future projects on your machine.
The full name and email address should match the ones you use in GitLab.
1. In your terminal, add your full name. For example:
```shell
git config --global user.name "Sidney Jones"
```
1. Add your email address. For example:
```shell
git config --global user.email "your_email_address@example.com"
```
1. To check the configuration, run:
```shell
git config --global --list
```
{{< /tab >}}
{{< /tabs >}}
### Check Git configuration settings
To check your configured Git settings, run:
```shell
git config user.name && git config user.email
```
## Related topics
- [Git configuration documentation](https://git-scm.com/book/en/v2/Customizing-Git-Git-Configuration)
- [Use SSH keys to communicate with GitLab](../../../user/ssh.md)
|
---
stage: Create
group: Source Code
info: To determine the technical writer assigned to the Stage/Group associated with
this page, see https://handbook.gitlab.com/handbook/product/ux/technical-writing/#assignments
description: How to install Git on your local machine.
title: Install Git
breadcrumbs:
- doc
- topics
- git
- how_to_install_git
---
To contribute to GitLab projects, you must download, install, and configure the Git client on
your local machine. GitLab uses the SSH protocol to securely communicate with Git.
With SSH, you can authenticate to the GitLab remote server without entering your username
and password each time.
For information on downloading and installing Git on other operating systems, see the
[official Git website](https://git-scm.com/downloads).
After you install and configure Git, [generate and add an SSH key pair](../../../user/ssh.md#generate-an-ssh-key-pair)
to your GitLab account.
## Install and update Git
{{< tabs >}}
{{< tab title="macOS" >}}
Though a version of Git is supplied by macOS, you should install the latest version of Git. A common way to
install Git is with [Homebrew](https://brew.sh/index.html).
To install the latest version of Git on macOS with Homebrew:
1. If you've never installed Homebrew before, follow the
[Homebrew installation instructions](https://brew.sh/index.html).
1. In a terminal, install Git by running `brew install git`.
1. Verify that Git works on your local machine:
```shell
git --version
```
Keep Git up to date by periodically running the following command:
```shell
brew update && brew upgrade git
```
{{< /tab >}}
{{< tab title="Ubuntu Linux" >}}
Though a version of Git is supplied by Ubuntu, you should install the latest version of Git. The latest version is
available using a Personal Package Archive (PPA).
To install the latest version of Git on Ubuntu Linux with a PPA:
1. In a terminal, configure the required PPA, update the list of Ubuntu packages, and install `git`:
```shell
sudo apt-add-repository ppa:git-core/ppa
sudo apt-get update
sudo apt-get install git
```
1. Verify that Git works on your local machine:
```shell
git --version
```
Keep Git up to date by periodically running the following command:
```shell
sudo apt-get update && sudo apt-get install git
```
{{< /tab >}}
{{< /tabs >}}
## Configure Git
To start using Git from your local machine, you must enter your credentials
to identify yourself as the author of your work.
You can configure your Git identity locally or globally:
- Locally: Use for the current project only.
- Globally: Use for all current and future projects.
{{< tabs >}}
{{< tab title="Local setup" >}}
Configure your Git identity locally to use it for the current project only.
The full name and email address should match the ones you use in GitLab.
1. In your terminal, add your full name. For example:
```shell
git config --local user.name "Alex Smith"
```
1. Add your email address. For example:
```shell
git config --local user.email "your_email_address@example.com"
```
1. To check the configuration, run:
```shell
git config --local --list
```
{{< /tab >}}
{{< tab title="Global setup" >}}
Configure your Git identity globally to use it for all current and future projects on your machine.
The full name and email address should match the ones you use in GitLab.
1. In your terminal, add your full name. For example:
```shell
git config --global user.name "Sidney Jones"
```
1. Add your email address. For example:
```shell
git config --global user.email "your_email_address@example.com"
```
1. To check the configuration, run:
```shell
git config --global --list
```
{{< /tab >}}
{{< /tabs >}}
### Check Git configuration settings
To check your configured Git settings, run:
```shell
git config user.name && git config user.email
```
## Related topics
- [Git configuration documentation](https://git-scm.com/book/en/v2/Customizing-Git-Git-Configuration)
- [Use SSH keys to communicate with GitLab](../../../user/ssh.md)
|
https://docs.gitlab.com/topics/git/troubleshooting
|
https://gitlab.com/gitlab-org/gitlab/-/tree/master/doc/topics/git/troubleshooting.md
|
2025-08-13
|
doc/topics/git/lfs
|
[
"doc",
"topics",
"git",
"lfs"
] |
troubleshooting.md
|
Create
|
Source Code
|
To determine the technical writer assigned to the Stage/Group associated with this page, see https://handbook.gitlab.com/handbook/product/ux/technical-writing/#assignments
|
Troubleshooting Git LFS
| null |
When working with Git LFS, you might encounter the following issues.
- The Git LFS original v1 API is unsupported.
- Git LFS requests use HTTPS credentials, which means you should use a Git
[credentials store](https://git-scm.com/book/en/v2/Git-Tools-Credential-Storage).
- [Group wikis](../../../user/project/wiki/group.md) do not support Git LFS.
## Error: repository or object not found
This error can occur for a few reasons, including:
- You don't have permissions to access certain LFS object. Confirm you have
permission to push to the project, or fetch from the project.
- The project isn't allowed to access the LFS object. The LFS object you want
to push (or fetch) is no longer available to the project. In most cases, the object
has been removed from the server.
- The local Git repository is using deprecated version of the Git LFS API. Update
your local copy of Git LFS and try again.
## Invalid status for `<url>` : 501
Git LFS logs the failures into a log file. To view this log file:
1. In your terminal window, go to your project's directory.
1. Run this command to see recent log files:
```shell
git lfs logs last
```
These problems can cause `501` errors:
- Git LFS is not enabled in your project's settings. Check your project settings and
enable Git LFS.
- Git LFS support is not enabled on the GitLab server. Check with your GitLab
administrator why Git LFS is not enabled on the server. See
[LFS administration documentation](../../../administration/lfs/_index.md) for instructions
on how to enable Git LFS support.
- The Git LFS client version is not supported by GitLab server. You should:
1. Check your Git LFS version with `git lfs version`.
1. Check the Git configuration of your project for traces of the deprecated API
with `git lfs -l`. If your configuration sets `batch = false`,
remove the line, then update your Git LFS client. GitLab supports only
versions 1.0.1 and newer.
## Credentials are always required when pushing an object
Git LFS authenticates the user with HTTP Basic Authentication on every push for
every object, so it requires user HTTPS credentials. By default, Git supports
remembering the credentials for each repository you use. For more information, see
the [official Git documentation](https://git-scm.com/docs/gitcredentials).
For example, you can tell Git to remember your password for a period of time in
which you expect to push objects. This example remembers your credentials for an hour
(3600 seconds), and you must authenticate again in an hour:
```shell
git config --global credential.helper 'cache --timeout=3600'
```
To store and encrypt credentials, see:
- MacOS: use `osxkeychain`.
- Windows: use `wincred` or the Microsoft
[Git Credential Manager for Windows](https://github.com/Microsoft/Git-Credential-Manager-for-Windows/releases).
To learn more about storing your user credentials, see the
[Git Credential Storage documentation](https://git-scm.com/book/en/v2/Git-Tools-Credential-Storage).
## LFS objects are missing on push
GitLab checks files on push to detect LFS pointers. If it detects LFS pointers,
GitLab tries to verify that those files already exist in LFS. If you use a separate
server for Git LFS, and you encounter this problem:
1. Verify you have installed Git LFS locally.
1. Consider a manual push with `git lfs push --all`.
If you store Git LFS files outside of GitLab, you can
[disable Git LFS](_index.md#enable-or-disable-git-lfs-for-a-project) on your project.
## Hosting LFS objects externally
You can host LFS objects externally by setting a custom LFS URL:
```shell
git config -f .lfsconfig lfs.url https://example.com/<project>.git/info/lfs
```
You might do this if you store LFS data on an appliance, like a Nexus Repository.
If you use an external LFS store, GitLab can't verify the LFS objects. Pushes then
fail if you have GitLab LFS support enabled.
To stop push failures, you can disable Git LFS support in your
[Project settings](_index.md#enable-or-disable-git-lfs-for-a-project). However, this approach
might not be desirable, because it also disables GitLab LFS features like:
- Verifying LFS objects.
- GitLab UI integration for LFS.
## I/O timeout when pushing LFS objects
If your network conditions are unstable, the Git LFS client might time out when trying to upload files.
You might see errors like:
```shell
LFS: Put "http://example.com/root/project.git/gitlab-lfs/objects/<OBJECT-ID>/15":
read tcp your-instance-ip:54544->your-instance-ip:443: i/o timeout
error: failed to push some refs to 'ssh://example.com:2222/root/project.git'
```
To fix this problem, set the client activity timeout a higher value. For example,
to set the timeout to 60 seconds:
```shell
git config lfs.activitytimeout 60
```
## Encountered `n` files that should have been pointers, but weren't
This error indicates the repository should be tracking a file with Git LFS, but
isn't. [Issue 326342](https://gitlab.com/gitlab-org/gitlab/-/issues/326342#note_586820485),
fixed in GitLab 16.10, was one cause of this problem.
To fix the problem, migrate the affected files, and push them up to the repository:
1. Migrate the file to LFS:
```shell
git lfs migrate import --yes --no-rewrite "<your-file>"
```
1. Push back to your repository:
```shell
git push
```
1. Optional. Clean up your `.git` folder:
```shell
git reflog expire --expire-unreachable=now --all
git gc --prune=now
```
## LFS objects not checked out automatically
You might encounter an issue where Git LFS objects are not automatically checked out. When
this happens, the files exist but contain pointer references instead of the actual content.
If you open these files, instead of seeing the expected file content, you might see an LFS pointer
that looks like this:
```plaintext
version https://git-lfs.github.com/spec/v1
oid sha256:d276d250bc645e27a1b0ab82f7baeb01f7148df7e4816c4b333de12d580caa29
size 2323563
```
This issue occurs when filenames do not match a rule in the `.gitattributes` file. LFS files are only
checked out automatically when they match a rule in `.gitattributes`.
In `git-lfs` v3.6.0, this behavior changed and [how LFS files are matched was optimized](https://github.com/git-lfs/git-lfs/pull/5699).
GitLab Runner v17.7.0 upgraded the default helper image to use `git-lfs` v3.6.0.
For consistent behavior across different operating systems with varying
case sensitivity, adjust your `.gitattributes` file to match different capitalization patterns.
For example, if you have LFS files named `image.jpg` and `wombat.JPG`, use case-insensitive regular
expressions in your `.gitattributes` file:
```plaintext
*.[jJ][pP][gG] filter=lfs diff=lfs merge=lfs -text
*.[jJ][pP][eE][gG] filter=lfs diff=lfs merge=lfs -text
```
If you work exclusively on case-sensitive filesystems, such as most
Linux distributions, you can use simpler patterns. For example:
```plaintext
*.jpg filter=lfs diff=lfs merge=lfs -text
*.jpeg filter=lfs diff=lfs merge=lfs -text
```
## Warning: Possible LFS configuration issue
You might see a warning in the GitLab UI that states:
```plaintext
Possible LFS configuration issue. This project contains LFS objects but there is no .gitattributes file.
You can ignore this message if you recently added a .gitattributes file.
```
This warning occurs when Git LFS is enabled and contains LFS objects, but no `.gitattributes` file
is detected in the root directory of your project. Git supports placing `.gitattributes` files in
subdirectories, but GitLab only checks for this file in the root directory.
The workaround is to create an empty `.gitattributes` file in the root directory:
{{< tabs >}}
{{< tab title="With Git" >}}
1. Clone your repository::
```shell
git clone <repository>
cd repository
```
1. Create an empty `.gitattributes` file:
```shell
touch .gitattributes
git add .gitattributes
git commit -m "Add empty .gitattributes file to root directory"
git push
```
{{< /tab >}}
{{< tab title="In the UI" >}}
1. Select **Search or go to** and find your project.
1. Select the plus icon (**+**) and **New file**.
1. In the **Filename** field, enter `.gitattributes`.
1. Select **Commit changes**.
1. In the **Commit message** field, enter a commit message.
1. Select **Commit changes**.
{{< /tab >}}
{{< /tabs >}}
|
---
stage: Create
group: Source Code
info: To determine the technical writer assigned to the Stage/Group associated with
this page, see https://handbook.gitlab.com/handbook/product/ux/technical-writing/#assignments
title: Troubleshooting Git LFS
breadcrumbs:
- doc
- topics
- git
- lfs
---
When working with Git LFS, you might encounter the following issues.
- The Git LFS original v1 API is unsupported.
- Git LFS requests use HTTPS credentials, which means you should use a Git
[credentials store](https://git-scm.com/book/en/v2/Git-Tools-Credential-Storage).
- [Group wikis](../../../user/project/wiki/group.md) do not support Git LFS.
## Error: repository or object not found
This error can occur for a few reasons, including:
- You don't have permissions to access certain LFS object. Confirm you have
permission to push to the project, or fetch from the project.
- The project isn't allowed to access the LFS object. The LFS object you want
to push (or fetch) is no longer available to the project. In most cases, the object
has been removed from the server.
- The local Git repository is using deprecated version of the Git LFS API. Update
your local copy of Git LFS and try again.
## Invalid status for `<url>` : 501
Git LFS logs the failures into a log file. To view this log file:
1. In your terminal window, go to your project's directory.
1. Run this command to see recent log files:
```shell
git lfs logs last
```
These problems can cause `501` errors:
- Git LFS is not enabled in your project's settings. Check your project settings and
enable Git LFS.
- Git LFS support is not enabled on the GitLab server. Check with your GitLab
administrator why Git LFS is not enabled on the server. See
[LFS administration documentation](../../../administration/lfs/_index.md) for instructions
on how to enable Git LFS support.
- The Git LFS client version is not supported by GitLab server. You should:
1. Check your Git LFS version with `git lfs version`.
1. Check the Git configuration of your project for traces of the deprecated API
with `git lfs -l`. If your configuration sets `batch = false`,
remove the line, then update your Git LFS client. GitLab supports only
versions 1.0.1 and newer.
## Credentials are always required when pushing an object
Git LFS authenticates the user with HTTP Basic Authentication on every push for
every object, so it requires user HTTPS credentials. By default, Git supports
remembering the credentials for each repository you use. For more information, see
the [official Git documentation](https://git-scm.com/docs/gitcredentials).
For example, you can tell Git to remember your password for a period of time in
which you expect to push objects. This example remembers your credentials for an hour
(3600 seconds), and you must authenticate again in an hour:
```shell
git config --global credential.helper 'cache --timeout=3600'
```
To store and encrypt credentials, see:
- MacOS: use `osxkeychain`.
- Windows: use `wincred` or the Microsoft
[Git Credential Manager for Windows](https://github.com/Microsoft/Git-Credential-Manager-for-Windows/releases).
To learn more about storing your user credentials, see the
[Git Credential Storage documentation](https://git-scm.com/book/en/v2/Git-Tools-Credential-Storage).
## LFS objects are missing on push
GitLab checks files on push to detect LFS pointers. If it detects LFS pointers,
GitLab tries to verify that those files already exist in LFS. If you use a separate
server for Git LFS, and you encounter this problem:
1. Verify you have installed Git LFS locally.
1. Consider a manual push with `git lfs push --all`.
If you store Git LFS files outside of GitLab, you can
[disable Git LFS](_index.md#enable-or-disable-git-lfs-for-a-project) on your project.
## Hosting LFS objects externally
You can host LFS objects externally by setting a custom LFS URL:
```shell
git config -f .lfsconfig lfs.url https://example.com/<project>.git/info/lfs
```
You might do this if you store LFS data on an appliance, like a Nexus Repository.
If you use an external LFS store, GitLab can't verify the LFS objects. Pushes then
fail if you have GitLab LFS support enabled.
To stop push failures, you can disable Git LFS support in your
[Project settings](_index.md#enable-or-disable-git-lfs-for-a-project). However, this approach
might not be desirable, because it also disables GitLab LFS features like:
- Verifying LFS objects.
- GitLab UI integration for LFS.
## I/O timeout when pushing LFS objects
If your network conditions are unstable, the Git LFS client might time out when trying to upload files.
You might see errors like:
```shell
LFS: Put "http://example.com/root/project.git/gitlab-lfs/objects/<OBJECT-ID>/15":
read tcp your-instance-ip:54544->your-instance-ip:443: i/o timeout
error: failed to push some refs to 'ssh://example.com:2222/root/project.git'
```
To fix this problem, set the client activity timeout a higher value. For example,
to set the timeout to 60 seconds:
```shell
git config lfs.activitytimeout 60
```
## Encountered `n` files that should have been pointers, but weren't
This error indicates the repository should be tracking a file with Git LFS, but
isn't. [Issue 326342](https://gitlab.com/gitlab-org/gitlab/-/issues/326342#note_586820485),
fixed in GitLab 16.10, was one cause of this problem.
To fix the problem, migrate the affected files, and push them up to the repository:
1. Migrate the file to LFS:
```shell
git lfs migrate import --yes --no-rewrite "<your-file>"
```
1. Push back to your repository:
```shell
git push
```
1. Optional. Clean up your `.git` folder:
```shell
git reflog expire --expire-unreachable=now --all
git gc --prune=now
```
## LFS objects not checked out automatically
You might encounter an issue where Git LFS objects are not automatically checked out. When
this happens, the files exist but contain pointer references instead of the actual content.
If you open these files, instead of seeing the expected file content, you might see an LFS pointer
that looks like this:
```plaintext
version https://git-lfs.github.com/spec/v1
oid sha256:d276d250bc645e27a1b0ab82f7baeb01f7148df7e4816c4b333de12d580caa29
size 2323563
```
This issue occurs when filenames do not match a rule in the `.gitattributes` file. LFS files are only
checked out automatically when they match a rule in `.gitattributes`.
In `git-lfs` v3.6.0, this behavior changed and [how LFS files are matched was optimized](https://github.com/git-lfs/git-lfs/pull/5699).
GitLab Runner v17.7.0 upgraded the default helper image to use `git-lfs` v3.6.0.
For consistent behavior across different operating systems with varying
case sensitivity, adjust your `.gitattributes` file to match different capitalization patterns.
For example, if you have LFS files named `image.jpg` and `wombat.JPG`, use case-insensitive regular
expressions in your `.gitattributes` file:
```plaintext
*.[jJ][pP][gG] filter=lfs diff=lfs merge=lfs -text
*.[jJ][pP][eE][gG] filter=lfs diff=lfs merge=lfs -text
```
If you work exclusively on case-sensitive filesystems, such as most
Linux distributions, you can use simpler patterns. For example:
```plaintext
*.jpg filter=lfs diff=lfs merge=lfs -text
*.jpeg filter=lfs diff=lfs merge=lfs -text
```
## Warning: Possible LFS configuration issue
You might see a warning in the GitLab UI that states:
```plaintext
Possible LFS configuration issue. This project contains LFS objects but there is no .gitattributes file.
You can ignore this message if you recently added a .gitattributes file.
```
This warning occurs when Git LFS is enabled and contains LFS objects, but no `.gitattributes` file
is detected in the root directory of your project. Git supports placing `.gitattributes` files in
subdirectories, but GitLab only checks for this file in the root directory.
The workaround is to create an empty `.gitattributes` file in the root directory:
{{< tabs >}}
{{< tab title="With Git" >}}
1. Clone your repository::
```shell
git clone <repository>
cd repository
```
1. Create an empty `.gitattributes` file:
```shell
touch .gitattributes
git add .gitattributes
git commit -m "Add empty .gitattributes file to root directory"
git push
```
{{< /tab >}}
{{< tab title="In the UI" >}}
1. Select **Search or go to** and find your project.
1. Select the plus icon (**+**) and **New file**.
1. In the **Filename** field, enter `.gitattributes`.
1. Select **Commit changes**.
1. In the **Commit message** field, enter a commit message.
1. Select **Commit changes**.
{{< /tab >}}
{{< /tabs >}}
|
https://docs.gitlab.com/topics/git/lfs
|
https://gitlab.com/gitlab-org/gitlab/-/tree/master/doc/topics/git/_index.md
|
2025-08-13
|
doc/topics/git/lfs
|
[
"doc",
"topics",
"git",
"lfs"
] |
_index.md
|
Create
|
Source Code
|
To determine the technical writer assigned to the Stage/Group associated with this page, see https://handbook.gitlab.com/handbook/product/ux/technical-writing/#assignments
|
Git Large File Storage (LFS)
|
Use Git LFS to manage binary assets, like images and video, without bloating your Git repository's size.
|
Git Large File Storage (LFS) is an open source Git extension that helps Git repositories
manage large binary files efficiently. Git can't track changes to binary files
(like audio, video, or image files) the same way it tracks changes to text files.
While text-based files can generate plaintext diffs, any change to a binary file requires
Git to completely replace the file in the repository. Repeated changes to large files
increase your repository's size. Over time, this increase in size can slow down regular Git
operations like `clone`, `fetch`, or `pull`.
Use Git LFS to store large binary files outside of your Git repository, leaving only
a small, text-based pointer for Git to manage. When you add a file to your repository
using Git LFS, GitLab:
1. Adds the file to your project's configured object storage, instead of the Git repository.
1. Adds a pointer to your Git repository, instead of the large file. The pointer
contains information about your file, like this:
```plaintext
version https://git-lfs.github.com/spec/v1
oid sha256:lpca0iva5kpz9wva5rgsqsicxrxrkbjr0bh4sy6rz08g2c4tyc441rto5j5bctit
size 804
```
- Version - the version of the Git LFS specification in use
- OID - The hashing method used, and a unique object ID, in the form `{hash-method}:{hash}`.
- Size - The file size, in bytes.
1. Queues a job to recalculate your project's statistics, including storage size and
LFS object storage. Your LFS object storage is the sum of the size of all LFS
objects associated with your repository.
Files managed with Git LFS show a **LFS** badge next to the filename:
Git LFS clients use HTTP Basic authentication, and communicate with your server
over HTTPS. After you authenticate the request, the Git LFS client receives instructions
on where to fetch (or push) the large file.
Your Git repository remains smaller, which helps you adhere to repository size limits.
For more information, see repository size limits
[for GitLab Self-Managed](../../../administration/settings/account_and_limit_settings.md#repository-size-limit) and
[for GitLab SaaS](../../../user/gitlab_com/_index.md#account-and-limit-settings).
## Understand how Git LFS works with forks
When you fork a repository, your fork includes the upstream repository's existing LFS objects
that existed at the time of your fork. If you add new LFS objects to your fork,
they belong to only your fork, and not the upstream repository. The total object storage
increases only for your fork.
When you create a merge request from your fork back to the upstream project, and
your merge request contains a new Git LFS object, GitLab associates the new LFS object
with the upstream project after merge.
## Configure Git LFS for a project
{{< details >}}
- Tier: Free, Premium, Ultimate
- Offering: GitLab Self-Managed, GitLab Dedicated
{{< /details >}}
GitLab enables Git LFS by default for both GitLab Self-Managed and GitLab SaaS.
It offers both server settings and project-specific settings.
- To configure Git LFS on your instance, such as setting up remote object storage, see
[GitLab Git Large File Storage (LFS) Administration](../../../administration/lfs/_index.md).
- To configure Git LFS for a specific project:
1. In the root directory of your local copy of the repository, run `git lfs install`. This command
adds:
- A pre-push Git hook to your repository.
- A [`.gitattributes` file](../../../user/project/repository/files/git_attributes.md) to track
handling for individual files and file types.
1. Add the files and file types you want to track with Git LFS.
## Enable or disable Git LFS for a project
Git LFS is enabled by default for both GitLab Self-Managed and GitLab SaaS.
Prerequisites:
- You must have at least the Developer role for the project.
To enable or disable Git LFS for your project:
1. On the left sidebar, select **Search or go to** and find your project.
1. Select **Settings > General**.
1. Expand the **Visibility, project features, permissions** section.
1. Select the **Git Large File Storage (LFS)** toggle.
1. Select **Save changes**.
## Add and track files
You can add large files to Git LFS. This helps you manage files in Git repositories.
When you track files with Git LFS, they are replaced with text pointers in Git,
and stored on a remote server. For more information, see [Git LFS](../file_management.md#git-lfs).
When you [configure Git LFS for a project](#configure-git-lfs-for-a-project), ensure you have a
`.gitattributes` file in the root directory of the project. Without a root-level `.gitattributes` file,
the UI displays a warning even if you correctly configured LFS in your project subdirectories.
For more information, see [LFS configuration warning message](troubleshooting.md#warning-possible-lfs-configuration-issue).
## Clone a repository that uses Git LFS
When you clone a repository that uses Git LFS, Git detects the LFS-tracked files
and clones them over HTTPS. If you run `git clone` with a SSH URL, like
`user@hostname.com:group/project.git`, you must enter your GitLab credentials again for HTTPS
authentication.
By default, Git LFS operations occur over HTTPS, even when Git communicates with your repository over SSH.
In GitLab 17.2, [pure SSH support for LFS](https://gitlab.com/groups/gitlab-org/-/epics/11872) was introduced.
For information on how to enable this feature, see [Pure SSH transfer protocol](../../../administration/lfs/_index.md#pure-ssh-transfer-protocol).
To fetch new LFS objects for a repository you have already cloned, run this command:
```shell
git lfs fetch origin main
```
## Migrate an existing repository to Git LFS
Read the [`git-lfs-migrate` documentation](https://github.com/git-lfs/git-lfs/blob/main/docs/man/git-lfs-migrate.adoc)
on how to migrate an existing Git repository with Git LFS.
## Delete a Git LFS file from repository history
It's important to understand the differences between untracking a file in Git LFS and deleting a file:
- Untrack: The file remains on disk and in your repository history.
If users check out historical branches or tags, they still need the LFS version of the file.
- Delete: The file is removed but remains in your repository history.
To delete a tracked file with Git LFS, see [Remove a file](../undo.md#remove-a-file-from-a-repository).
To completely expunge all history of a file, past and present,
see [Handle sensitive information](../undo.md#handle-sensitive-information).
{{< alert type="warning" >}}
Expunging file history requires rewriting Git history. This action is destructive and irreversible.
{{< /alert >}}
## Reduce repository size after removing large files
If you need to remove large files from your repository's history, to reduce
the total size of your repository, see
[Reduce repository size](../../../user/project/repository/repository_size.md#methods-to-reduce-repository-size).
## Related topics
- Use Git LFS to set up [exclusive file locks](../file_management.md#configure-file-locks).
- Blog post: [Getting started with Git LFS](https://about.gitlab.com/blog/2017/01/30/getting-started-with-git-lfs-tutorial/)
- [Git LFS with Git](../file_management.md#git-lfs)
- [GitLab Git Large File Storage (LFS) Administration](../../../administration/lfs/_index.md) for GitLab Self-Managed
- [Troubleshooting Git LFS](troubleshooting.md)
- [The `.gitattributes` file](../../../user/project/repository/files/git_attributes.md)
|
---
stage: Create
group: Source Code
info: To determine the technical writer assigned to the Stage/Group associated with
this page, see https://handbook.gitlab.com/handbook/product/ux/technical-writing/#assignments
description: Use Git LFS to manage binary assets, like images and video, without bloating
your Git repository's size.
title: Git Large File Storage (LFS)
breadcrumbs:
- doc
- topics
- git
- lfs
---
Git Large File Storage (LFS) is an open source Git extension that helps Git repositories
manage large binary files efficiently. Git can't track changes to binary files
(like audio, video, or image files) the same way it tracks changes to text files.
While text-based files can generate plaintext diffs, any change to a binary file requires
Git to completely replace the file in the repository. Repeated changes to large files
increase your repository's size. Over time, this increase in size can slow down regular Git
operations like `clone`, `fetch`, or `pull`.
Use Git LFS to store large binary files outside of your Git repository, leaving only
a small, text-based pointer for Git to manage. When you add a file to your repository
using Git LFS, GitLab:
1. Adds the file to your project's configured object storage, instead of the Git repository.
1. Adds a pointer to your Git repository, instead of the large file. The pointer
contains information about your file, like this:
```plaintext
version https://git-lfs.github.com/spec/v1
oid sha256:lpca0iva5kpz9wva5rgsqsicxrxrkbjr0bh4sy6rz08g2c4tyc441rto5j5bctit
size 804
```
- Version - the version of the Git LFS specification in use
- OID - The hashing method used, and a unique object ID, in the form `{hash-method}:{hash}`.
- Size - The file size, in bytes.
1. Queues a job to recalculate your project's statistics, including storage size and
LFS object storage. Your LFS object storage is the sum of the size of all LFS
objects associated with your repository.
Files managed with Git LFS show a **LFS** badge next to the filename:
Git LFS clients use HTTP Basic authentication, and communicate with your server
over HTTPS. After you authenticate the request, the Git LFS client receives instructions
on where to fetch (or push) the large file.
Your Git repository remains smaller, which helps you adhere to repository size limits.
For more information, see repository size limits
[for GitLab Self-Managed](../../../administration/settings/account_and_limit_settings.md#repository-size-limit) and
[for GitLab SaaS](../../../user/gitlab_com/_index.md#account-and-limit-settings).
## Understand how Git LFS works with forks
When you fork a repository, your fork includes the upstream repository's existing LFS objects
that existed at the time of your fork. If you add new LFS objects to your fork,
they belong to only your fork, and not the upstream repository. The total object storage
increases only for your fork.
When you create a merge request from your fork back to the upstream project, and
your merge request contains a new Git LFS object, GitLab associates the new LFS object
with the upstream project after merge.
## Configure Git LFS for a project
{{< details >}}
- Tier: Free, Premium, Ultimate
- Offering: GitLab Self-Managed, GitLab Dedicated
{{< /details >}}
GitLab enables Git LFS by default for both GitLab Self-Managed and GitLab SaaS.
It offers both server settings and project-specific settings.
- To configure Git LFS on your instance, such as setting up remote object storage, see
[GitLab Git Large File Storage (LFS) Administration](../../../administration/lfs/_index.md).
- To configure Git LFS for a specific project:
1. In the root directory of your local copy of the repository, run `git lfs install`. This command
adds:
- A pre-push Git hook to your repository.
- A [`.gitattributes` file](../../../user/project/repository/files/git_attributes.md) to track
handling for individual files and file types.
1. Add the files and file types you want to track with Git LFS.
## Enable or disable Git LFS for a project
Git LFS is enabled by default for both GitLab Self-Managed and GitLab SaaS.
Prerequisites:
- You must have at least the Developer role for the project.
To enable or disable Git LFS for your project:
1. On the left sidebar, select **Search or go to** and find your project.
1. Select **Settings > General**.
1. Expand the **Visibility, project features, permissions** section.
1. Select the **Git Large File Storage (LFS)** toggle.
1. Select **Save changes**.
## Add and track files
You can add large files to Git LFS. This helps you manage files in Git repositories.
When you track files with Git LFS, they are replaced with text pointers in Git,
and stored on a remote server. For more information, see [Git LFS](../file_management.md#git-lfs).
When you [configure Git LFS for a project](#configure-git-lfs-for-a-project), ensure you have a
`.gitattributes` file in the root directory of the project. Without a root-level `.gitattributes` file,
the UI displays a warning even if you correctly configured LFS in your project subdirectories.
For more information, see [LFS configuration warning message](troubleshooting.md#warning-possible-lfs-configuration-issue).
## Clone a repository that uses Git LFS
When you clone a repository that uses Git LFS, Git detects the LFS-tracked files
and clones them over HTTPS. If you run `git clone` with a SSH URL, like
`user@hostname.com:group/project.git`, you must enter your GitLab credentials again for HTTPS
authentication.
By default, Git LFS operations occur over HTTPS, even when Git communicates with your repository over SSH.
In GitLab 17.2, [pure SSH support for LFS](https://gitlab.com/groups/gitlab-org/-/epics/11872) was introduced.
For information on how to enable this feature, see [Pure SSH transfer protocol](../../../administration/lfs/_index.md#pure-ssh-transfer-protocol).
To fetch new LFS objects for a repository you have already cloned, run this command:
```shell
git lfs fetch origin main
```
## Migrate an existing repository to Git LFS
Read the [`git-lfs-migrate` documentation](https://github.com/git-lfs/git-lfs/blob/main/docs/man/git-lfs-migrate.adoc)
on how to migrate an existing Git repository with Git LFS.
## Delete a Git LFS file from repository history
It's important to understand the differences between untracking a file in Git LFS and deleting a file:
- Untrack: The file remains on disk and in your repository history.
If users check out historical branches or tags, they still need the LFS version of the file.
- Delete: The file is removed but remains in your repository history.
To delete a tracked file with Git LFS, see [Remove a file](../undo.md#remove-a-file-from-a-repository).
To completely expunge all history of a file, past and present,
see [Handle sensitive information](../undo.md#handle-sensitive-information).
{{< alert type="warning" >}}
Expunging file history requires rewriting Git history. This action is destructive and irreversible.
{{< /alert >}}
## Reduce repository size after removing large files
If you need to remove large files from your repository's history, to reduce
the total size of your repository, see
[Reduce repository size](../../../user/project/repository/repository_size.md#methods-to-reduce-repository-size).
## Related topics
- Use Git LFS to set up [exclusive file locks](../file_management.md#configure-file-locks).
- Blog post: [Getting started with Git LFS](https://about.gitlab.com/blog/2017/01/30/getting-started-with-git-lfs-tutorial/)
- [Git LFS with Git](../file_management.md#git-lfs)
- [GitLab Git Large File Storage (LFS) Administration](../../../administration/lfs/_index.md) for GitLab Self-Managed
- [Troubleshooting Git LFS](troubleshooting.md)
- [The `.gitattributes` file](../../../user/project/repository/files/git_attributes.md)
|
https://docs.gitlab.com/topics/quick_start_guide
|
https://gitlab.com/gitlab-org/gitlab/-/tree/master/doc/topics/quick_start_guide.md
|
2025-08-13
|
doc/topics/offline
|
[
"doc",
"topics",
"offline"
] |
quick_start_guide.md
|
GitLab Delivery
|
Self Managed
|
To determine the technical writer assigned to the Stage/Group associated with this page, see https://handbook.gitlab.com/handbook/product/ux/technical-writing/#assignments
|
Install an offline GitLab Self-Managed instance
| null |
{{< details >}}
- Tier: Free, Premium, Ultimate
- Offering: GitLab Self-Managed
{{< /details >}}
This is a step-by-step guide that helps you install, configure, and use a GitLab Self-Managed
instance entirely offline.
## Installation
{{< alert type="note" >}}
This guide assumes the server is Ubuntu 20.04 using the [Linux package installation method](https://docs.gitlab.com/omnibus/) and is running GitLab [Enterprise Edition](https://about.gitlab.com/install/ce-or-ee/). Instructions for other servers may vary.
This guide also assumes the server host resolves as `my-host.internal`, which you should replace with your
server's FQDN, and that you have access to a different server with Internet access to download the required package files.
{{< /alert >}}
<i class="fa fa-youtube-play youtube" aria-hidden="true"></i>
For a video walkthrough of this process, see [Offline GitLab Installation: Downloading & Installing](https://www.youtube.com/watch?v=TJaq4ua2Prw).
### Download the GitLab package
You should [manually download the GitLab package](../../update/package/_index.md#by-using-a-downloaded-package) and relevant dependencies using a server of the same operating system type that has access to the Internet.
If your offline environment has no local network access, you must manually transport the relevant package through physical media, such as a USB drive.
In Ubuntu, this can be performed on a server with Internet access using the following commands:
```shell
# Download the bash script to prepare the repository
curl --silent "https://packages.gitlab.com/install/repositories/gitlab/gitlab-ee/script.deb.sh" | sudo bash
# Download the gitlab-ee package and dependencies to /var/cache/apt/archives
sudo apt-get install --download-only gitlab-ee
# Copy the contents of the apt download folder to a mounted media device
sudo cp /var/cache/apt/archives/*.deb /path/to/mount
```
### Install the GitLab package
Prerequisites:
- Before installing the GitLab package on your offline environment, ensure that you have installed all required dependencies first.
If you are using Ubuntu, you can install the dependency `.deb` packages you copied across with `dpkg`. Do not install the GitLab package yet.
```shell
# Go to the physical media device
sudo cd /path/to/mount
# Install the dependency packages
sudo dpkg -i <package_name>.deb
```
[Use the relevant commands for your operating system to install the package](../../update/package/_index.md#by-using-a-downloaded-package) but make sure to specify an `http`
URL for the `EXTERNAL_URL` installation step. Once installed, we can manually
configure the SSL ourselves.
It is strongly recommended to set up a domain for IP resolution rather than bind
to the server's IP address. This better ensures a stable target for our certs' CN
and makes long-term resolution simpler.
The following example for Ubuntu specifies the `EXTERNAL_URL` using HTTP and installs the GitLab package:
```shell
sudo EXTERNAL_URL="http://my-host.internal" dpkg -i <gitlab_package_name>.deb
```
## Enabling SSL
Follow these steps to enable SSL for your fresh instance. These steps reflect those for
[manually configuring SSL in the NGINX configuration](https://docs.gitlab.com/omnibus/settings/ssl/#configure-https-manually):
1. Make the following changes to `/etc/gitlab/gitlab.rb`:
```ruby
# Update external_url from "http" to "https"
external_url "https://my-host.internal"
# Set Let's Encrypt to false
letsencrypt['enable'] = false
```
1. Create the following directories with the appropriate permissions for generating self-signed
certificates:
```shell
sudo mkdir -p /etc/gitlab/ssl
sudo chmod 755 /etc/gitlab/ssl
sudo openssl req -x509 -nodes -days 365 -newkey rsa:2048 -keyout /etc/gitlab/ssl/my-host.internal.key -out /etc/gitlab/ssl/my-host.internal.crt
```
1. Reconfigure your instance to apply the changes:
```shell
sudo gitlab-ctl reconfigure
```
## Enabling the GitLab container registry
Follow these steps to enable the container registry. These steps reflect those for
[configuring the container registry under an existing domain](../../administration/packages/container_registry.md#configure-container-registry-under-an-existing-gitlab-domain):
1. Make the following changes to `/etc/gitlab/gitlab.rb`:
```ruby
# Change external_registry_url to match external_url, but append the port 4567
external_url "https://gitlab.example.com"
registry_external_url "https://gitlab.example.com:4567"
```
1. Reconfigure your instance to apply the changes:
```shell
sudo gitlab-ctl reconfigure
```
## Allow the Docker daemon to trust the registry and GitLab Runner
Provide your Docker daemon with your certs by
[following the steps for using trusted certificates with your registry](../../administration/packages/container_registry_troubleshooting.md#using-self-signed-certificates-with-container-registry):
```shell
sudo mkdir -p /etc/docker/certs.d/my-host.internal:5000
sudo cp /etc/gitlab/ssl/my-host.internal.crt /etc/docker/certs.d/my-host.internal:5000/ca.crt
```
Provide your GitLab Runner (to be installed next) with your certs by
[following the steps for using trusted certificates with your runner](https://docs.gitlab.com/runner/install/docker.html#installing-trusted-ssl-server-certificates):
```shell
sudo mkdir -p /etc/gitlab-runner/certs
sudo cp /etc/gitlab/ssl/my-host.internal.crt /etc/gitlab-runner/certs/ca.crt
```
## Enabling GitLab Runner
[Following a similar process to the steps for installing our GitLab Runner as a Docker service](https://docs.gitlab.com/runner/install/docker.html#install-the-docker-image-and-start-the-container), we must first register our runner:
```shell
$ sudo docker run --rm -it -v /etc/gitlab-runner:/etc/gitlab-runner gitlab/gitlab-runner register
Updating CA certificates...
Runtime platform arch=amd64 os=linux pid=7 revision=1b659122 version=12.8.0
Running in system-mode.
Enter the GitLab instance URL (for example, https://gitlab.com/):
https://my-host.internal
Enter the registration token:
XXXXXXXXXXX
Enter a description for the runner:
[eb18856e13c0]:
Enter tags for the runner (comma-separated):
Enter optional maintenance note for the runner:
Registering runner... succeeded runner=FSMwkvLZ
Please enter the executor: custom, docker, virtualbox, kubernetes, docker+machine, docker-ssh+machine, docker-ssh, parallels, shell, ssh:
docker
Please enter the default Docker image (for example, ruby:2.6):
ruby:2.6
Runner registered successfully. Feel free to start it, but if it's running already the config should be automatically reloaded!
```
Now we must add some additional configuration to our runner:
Make the following changes to `/etc/gitlab-runner/config.toml`:
- Add Docker socket to volumes `volumes = ["/var/run/docker.sock:/var/run/docker.sock", "/cache"]`
- Add `pull_policy = "if-not-present"` to the executor configuration
Now we can start our runner:
```shell
sudo docker run -d --restart always --name gitlab-runner -v /etc/gitlab-runner:/etc/gitlab-runner -v /var/run/docker.sock:/var/run/docker.sock gitlab/gitlab-runner:latest
90646b6587127906a4ee3f2e51454c6e1f10f26fc7a0b03d9928d8d0d5897b64
```
### Authenticating the registry against the host OS
As noted in [Docker registry authentication documentation](https://distribution.github.io/distribution/about/insecure/#docker-still-complains-about-the-certificate-when-using-authentication),
certain versions of Docker require trusting the certificate chain at the OS level.
In the case of Ubuntu, this involves using `update-ca-certificates`:
```shell
sudo cp /etc/docker/certs.d/my-host.internal\:5000/ca.crt /usr/local/share/ca-certificates/my-host.internal.crt
sudo update-ca-certificates
```
If all goes well, this is what you should see:
```plaintext
1 added, 0 removed; done.
Running hooks in /etc/ca-certificates/update.d...
done.
```
### Disable Version Check and Service Ping
Version Check and Service Ping improve the GitLab user experience and ensure that
users are on the most up-to-date instances of GitLab. These two services can be turned off for offline
environments so that they do not attempt and fail to reach out to GitLab services.
For more information, see [Enable or disable service ping](../../administration/settings/usage_statistics.md#enable-or-disable-service-ping).
### Disable runner version management
Runner version management retrieves the latest runner versions from GitLab to
[determine which runners in your environment are out of date](../../ci/runners/runners_scope.md#determine-which-runners-need-to-be-upgraded).
You must [disable runner version management](../../administration/settings/continuous_integration.md#control-runner-version-management)
for offline environments.
### Configure NTP
Gitaly Cluster (Praefect) assumes `pool.ntp.org` is accessible. If `pool.ntp.org` is not accessible, [customize the time server setting](../../administration/gitaly/praefect/configure.md#customize-time-server-setting) on the Gitaly
and Praefect servers so they can use an accessible NTP server.
On offline instances, the [GitLab Geo check Rake task](../../administration/geo/replication/troubleshooting/common.md#can-geo-detect-the-current-site-correctly)
always fails because it uses `pool.ntp.org`. This error can be ignored but you can
[read more about how to work around it](../../administration/geo/replication/troubleshooting/common.md#message-machine-clock-is-synchronized--exception).
## Enabling the Package Metadata Database
Enabling the Package Metadata Database is required to enable
[Continuous Vulnerability Scanning](../../user/application_security/continuous_vulnerability_scanning/_index.md)
and [license scanning of CycloneDX files](../../user/compliance/license_scanning_of_cyclonedx_files/_index.md).
This process requires the use of License and/or Advisory Data under what is collectively called the Package Metadata Database, which is licensed under the [EE License](https://storage.googleapis.com/prod-export-license-bucket-1a6c642fc4de57d4/LICENSE).
Note the following in relation to use of the Package Metadata Database:
- We may change or discontinue all or any part of the Package Metadata Database, at any time and without notice, at our sole discretion.
- The Package Metadata Database may contain links to third-party websites or resources. We provide these links only as a convenience and are not responsible for any third-party data, content, products, or services from those websites or resources or links displayed on such websites.
- The Package Metadata Database is based in part on information made available by third parties, and GitLab is not responsible for the accuracy or completeness of content made available.
Package metadata is stored in the following Google Cloud Provider (GCP) buckets:
- License Scanning - `prod-export-license-bucket-1a6c642fc4de57d4`
- Dependency Scanning - `prod-export-advisory-bucket-1a6c642fc4de57d4`
### Using the gsutil tool to download the package metadata exports
1. Install the [`gsutil`](https://cloud.google.com/storage/docs/gsutil_install) tool.
1. Find the root of the GitLab Rails directory.
```shell
export GITLAB_RAILS_ROOT_DIR="$(gitlab-rails runner 'puts Rails.root.to_s')"
echo $GITLAB_RAILS_ROOT_DIR
```
1. Set the type of data you wish to sync.
```shell
# For License Scanning
export PKG_METADATA_BUCKET=prod-export-license-bucket-1a6c642fc4de57d4
export DATA_DIR="licenses"
# For Dependency Scanning
export PKG_METADATA_BUCKET=prod-export-advisory-bucket-1a6c642fc4de57d4
export DATA_DIR="advisories"
```
1. Download the package metadata exports.
```shell
# To download the package metadata exports, an outbound connection to Google Cloud Storage bucket must be allowed.
mkdir -p "$GITLAB_RAILS_ROOT_DIR/vendor/package_metadata/$DATA_DIR"
gsutil -m rsync -r -d gs://$PKG_METADATA_BUCKET "$GITLAB_RAILS_ROOT_DIR/vendor/package_metadata/$DATA_DIR"
# Alternatively, if the GitLab instance is not allowed to connect to the Google Cloud Storage bucket, the package metadata
# exports can be downloaded using a machine with the allowed access, and then copied to the root of the GitLab Rails directory.
rsync rsync://example_username@gitlab.example.com/package_metadata/$DATA_DIR "$GITLAB_RAILS_ROOT_DIR/vendor/package_metadata/$DATA_DIR"
```
### Using the Google Cloud Storage REST API to download the package metadata exports
The package metadata exports can also be downloaded using the Google Cloud Storage API. The contents are available at [https://storage.googleapis.com/storage/v1/b/prod-export-license-bucket-1a6c642fc4de57d4/o](https://storage.googleapis.com/storage/v1/b/prod-export-license-bucket-1a6c642fc4de57d4/o) and [https://storage.googleapis.com/storage/v1/b/prod-export-advisory-bucket-1a6c642fc4de57d4/o](https://storage.googleapis.com/storage/v1/b/prod-export-advisory-bucket-1a6c642fc4de57d4/o). The following is an example of how this can be downloaded using [cURL](https://curl.se/) and [jq](https://stedolan.github.io/jq/).
```shell
#!/bin/bash
set -euo pipefail
DATA_TYPE=$1
GITLAB_RAILS_ROOT_DIR="$(gitlab-rails runner 'puts Rails.root.to_s')"
if [ "$DATA_TYPE" == "license" ]; then
PKG_METADATA_DIR="$GITLAB_RAILS_ROOT_DIR/vendor/package_metadata/licenses"
elif [ "$DATA_TYPE" == "advisory" ]; then
PKG_METADATA_DIR="$GITLAB_RAILS_ROOT_DIR/vendor/package_metadata/advisories"
else
echo "Usage: import_script.sh [license|advisory]"
exit 1
fi
PKG_METADATA_BUCKET="prod-export-$DATA_TYPE-bucket-1a6c642fc4de57d4"
PKG_METADATA_DOWNLOADS_OUTPUT_FILE="/tmp/package_metadata_${DATA_TYPE}_object_links.tsv"
# Download the contents of the bucket
# The script downloads all the objects and creates files with a maximum 1000 objects per file in JSON format.
MAX_RESULTS=1000
TEMP_FILE="out.json"
curl --silent --show-error --request GET "https://storage.googleapis.com/storage/v1/b/$PKG_METADATA_BUCKET/o?maxResults=$MAX_RESULTS" >"$TEMP_FILE"
NEXT_PAGE_TOKEN="$(jq -r '.nextPageToken' $TEMP_FILE)"
jq -r '.items[] | [.name, .mediaLink] | @tsv' "$TEMP_FILE" >"$PKG_METADATA_DOWNLOADS_OUTPUT_FILE"
while [ "$NEXT_PAGE_TOKEN" != "null" ]; do
curl --silent --show-error --request GET "https://storage.googleapis.com/storage/v1/b/$PKG_METADATA_BUCKET/o?maxResults=$MAX_RESULTS&pageToken=$NEXT_PAGE_TOKEN" >"$TEMP_FILE"
NEXT_PAGE_TOKEN="$(jq -r '.nextPageToken' $TEMP_FILE)"
jq -r '.items[] | [.name, .mediaLink] | @tsv' "$TEMP_FILE" >>"$PKG_METADATA_DOWNLOADS_OUTPUT_FILE"
#use for API rate-limiting
sleep 1
done
trap 'rm -f "$TEMP_FILE"' EXIT
echo "Fetched $DATA_TYPE export manifest"
# Parse the links and names for the bucket objects and output them into a tsv file
echo -e "Saving package metadata exports to $PKG_METADATA_DIR\n"
# Track how many objects will be downloaded
INDEX=1
TOTAL_OBJECT_COUNT="$(wc -l "$PKG_METADATA_DOWNLOADS_OUTPUT_FILE" | awk '{print $1}')"
# Download the objects
while IFS= read -r line; do
FILE="$(echo -n "$line" | awk '{print $1}')"
URL="$(echo -n "$line" | awk '{print $2}')"
OUTPUT_PATH="$PKG_METADATA_DIR/$FILE"
echo "Downloading $FILE"
if [ ! -f "$OUTPUT_PATH" ]; then
curl --progress-bar --create-dirs --output "$OUTPUT_PATH" --request "GET" "$URL"
else
echo "Existing file found"
fi
echo -e "$INDEX of $TOTAL_OBJECT_COUNT objects downloaded\n"
INDEX=$((INDEX + 1))
done <"$PKG_METADATA_DOWNLOADS_OUTPUT_FILE"
echo "All objects saved to $PKG_METADATA_DIR"
```
### Automatic synchronization
Your GitLab instance is synchronized [regularly](https://gitlab.com/gitlab-org/gitlab/-/blob/63a187d47f6da353ba4514650bbbbeb99c356325/config/initializers/1_settings.rb#L840-842) with the contents of the `package_metadata` directory.
To automatically update your local copy with the upstream changes, a cron job can be added to periodically download new exports. For example, the following crontabs can be added to set up a cron job that runs every 30 minutes.
For License Scanning:
```plaintext
*/30 * * * * gsutil -m rsync -r -d -y "^v1\/" gs://prod-export-license-bucket-1a6c642fc4de57d4 $GITLAB_RAILS_ROOT_DIR/vendor/package_metadata/licenses
```
For Dependency Scanning:
```plaintext
*/30 * * * * gsutil -m rsync -r -d gs://prod-export-advisory-bucket-1a6c642fc4de57d4 $GITLAB_RAILS_ROOT_DIR/vendor/package_metadata/advisories
```
### Change note
The directory for package metadata changed with the release of 16.2 from `vendor/package_metadata_db` to `vendor/package_metadata/licenses`. If this directory already exists on the instance and Dependency Scanning needs to be added then you need to take the following steps.
1. Rename the licenses directory: `mv vendor/package_metadata_db vendor/package_metadata/licenses`.
1. Update any automation scripts or commands saved to change `vendor/package_metadata_db` to `vendor/package_metadata/licenses`.
1. Update any cron entries to change `vendor/package_metadata_db` to `vendor/package_metadata/licenses`.
```shell
sed -i '.bckup' -e 's#vendor/package_metadata_db#vendor/package_metadata/licenses#g' [FILE ...]
```
### Troubleshooting
#### Missing database data
If license or advisory data is missing from the dependency list or MR pages, one possible cause of this is that the database has not been synchronized with the export data.
`package_metadata` synchronization is triggered by using cron jobs ([advisory sync](https://gitlab.com/gitlab-org/gitlab/-/blob/16-3-stable-ee/config/initializers/1_settings.rb#L864-866) and [license sync](https://gitlab.com/gitlab-org/gitlab/-/blob/16-3-stable-ee/config/initializers/1_settings.rb#L855-857)) and imports only the package registry types enabled in [admin settings](../../administration/settings/security_and_compliance.md#choose-package-registry-metadata-to-sync).
The file structure in `vendor/package_metadata` must coincide with the package registry type enabled previously. For example, to sync `maven` license or advisory data, the package metadata directory under the Rails directory must have the following structure:
- For licenses:`$GITLAB_RAILS_ROOT_DIR/vendor/package_metadata/licenses/v2/maven/**/*.ndjson`.
- For advisories:`$GITLAB_RAILS_ROOT_DIR/vendor/package_metadata/advisories/v2/maven/**/*.ndjson`.
After a successful run, data under the `pm_` tables in the database should be populated (check using [Rails console](../../administration/operations/rails_console.md)):
- For licenses: `sudo gitlab-rails runner "puts \"Package model has #{PackageMetadata::Package.where(purl_type: 'maven').size} packages\""`
- For advisories: `sudo gitlab-rails runner "puts \"Advisory model has #{PackageMetadata::AffectedPackage.where(purl_type: 'maven').size} packages\""`
Additionally, checkpoint data should exist for the particular package registry being synchronized. For Maven, for example, there should be a checkpoint created after a successful sync run:
- For licenses: `sudo gitlab-rails runner "puts \"maven data has been synced up to #{PackageMetadata::Checkpoint.where(data_type: 'licenses', purl_type: 'maven')}\""`
- For advisories: `sudo gitlab-rails runner "puts \"maven data has been synced up to #{PackageMetadata::Checkpoint.where(data_type: 'advisories', purl_type: 'maven')}\""`
Finally, you can check the [`application_json.log`](../../administration/logs/_index.md#application_jsonlog) logs to verify that the
sync job has run and is without error by searching for `DEBUG` messages where the class is `PackageMetadata::SyncService`. Example: `{"severity":"DEBUG","time":"2023-06-22T16:41:00.825Z","correlation_id":"a6e80150836b4bb317313a3fe6d0bbd6","class":"PackageMetadata::SyncService","message":"Evaluating data for licenses:gcp/prod-export-license-bucket-1a6c642fc4de57d4/v2/pypi/1694703741/0.ndjson"}`.
|
---
stage: GitLab Delivery
group: Self Managed
info: To determine the technical writer assigned to the Stage/Group associated with
this page, see https://handbook.gitlab.com/handbook/product/ux/technical-writing/#assignments
title: Install an offline GitLab Self-Managed instance
breadcrumbs:
- doc
- topics
- offline
---
{{< details >}}
- Tier: Free, Premium, Ultimate
- Offering: GitLab Self-Managed
{{< /details >}}
This is a step-by-step guide that helps you install, configure, and use a GitLab Self-Managed
instance entirely offline.
## Installation
{{< alert type="note" >}}
This guide assumes the server is Ubuntu 20.04 using the [Linux package installation method](https://docs.gitlab.com/omnibus/) and is running GitLab [Enterprise Edition](https://about.gitlab.com/install/ce-or-ee/). Instructions for other servers may vary.
This guide also assumes the server host resolves as `my-host.internal`, which you should replace with your
server's FQDN, and that you have access to a different server with Internet access to download the required package files.
{{< /alert >}}
<i class="fa fa-youtube-play youtube" aria-hidden="true"></i>
For a video walkthrough of this process, see [Offline GitLab Installation: Downloading & Installing](https://www.youtube.com/watch?v=TJaq4ua2Prw).
### Download the GitLab package
You should [manually download the GitLab package](../../update/package/_index.md#by-using-a-downloaded-package) and relevant dependencies using a server of the same operating system type that has access to the Internet.
If your offline environment has no local network access, you must manually transport the relevant package through physical media, such as a USB drive.
In Ubuntu, this can be performed on a server with Internet access using the following commands:
```shell
# Download the bash script to prepare the repository
curl --silent "https://packages.gitlab.com/install/repositories/gitlab/gitlab-ee/script.deb.sh" | sudo bash
# Download the gitlab-ee package and dependencies to /var/cache/apt/archives
sudo apt-get install --download-only gitlab-ee
# Copy the contents of the apt download folder to a mounted media device
sudo cp /var/cache/apt/archives/*.deb /path/to/mount
```
### Install the GitLab package
Prerequisites:
- Before installing the GitLab package on your offline environment, ensure that you have installed all required dependencies first.
If you are using Ubuntu, you can install the dependency `.deb` packages you copied across with `dpkg`. Do not install the GitLab package yet.
```shell
# Go to the physical media device
sudo cd /path/to/mount
# Install the dependency packages
sudo dpkg -i <package_name>.deb
```
[Use the relevant commands for your operating system to install the package](../../update/package/_index.md#by-using-a-downloaded-package) but make sure to specify an `http`
URL for the `EXTERNAL_URL` installation step. Once installed, we can manually
configure the SSL ourselves.
It is strongly recommended to set up a domain for IP resolution rather than bind
to the server's IP address. This better ensures a stable target for our certs' CN
and makes long-term resolution simpler.
The following example for Ubuntu specifies the `EXTERNAL_URL` using HTTP and installs the GitLab package:
```shell
sudo EXTERNAL_URL="http://my-host.internal" dpkg -i <gitlab_package_name>.deb
```
## Enabling SSL
Follow these steps to enable SSL for your fresh instance. These steps reflect those for
[manually configuring SSL in the NGINX configuration](https://docs.gitlab.com/omnibus/settings/ssl/#configure-https-manually):
1. Make the following changes to `/etc/gitlab/gitlab.rb`:
```ruby
# Update external_url from "http" to "https"
external_url "https://my-host.internal"
# Set Let's Encrypt to false
letsencrypt['enable'] = false
```
1. Create the following directories with the appropriate permissions for generating self-signed
certificates:
```shell
sudo mkdir -p /etc/gitlab/ssl
sudo chmod 755 /etc/gitlab/ssl
sudo openssl req -x509 -nodes -days 365 -newkey rsa:2048 -keyout /etc/gitlab/ssl/my-host.internal.key -out /etc/gitlab/ssl/my-host.internal.crt
```
1. Reconfigure your instance to apply the changes:
```shell
sudo gitlab-ctl reconfigure
```
## Enabling the GitLab container registry
Follow these steps to enable the container registry. These steps reflect those for
[configuring the container registry under an existing domain](../../administration/packages/container_registry.md#configure-container-registry-under-an-existing-gitlab-domain):
1. Make the following changes to `/etc/gitlab/gitlab.rb`:
```ruby
# Change external_registry_url to match external_url, but append the port 4567
external_url "https://gitlab.example.com"
registry_external_url "https://gitlab.example.com:4567"
```
1. Reconfigure your instance to apply the changes:
```shell
sudo gitlab-ctl reconfigure
```
## Allow the Docker daemon to trust the registry and GitLab Runner
Provide your Docker daemon with your certs by
[following the steps for using trusted certificates with your registry](../../administration/packages/container_registry_troubleshooting.md#using-self-signed-certificates-with-container-registry):
```shell
sudo mkdir -p /etc/docker/certs.d/my-host.internal:5000
sudo cp /etc/gitlab/ssl/my-host.internal.crt /etc/docker/certs.d/my-host.internal:5000/ca.crt
```
Provide your GitLab Runner (to be installed next) with your certs by
[following the steps for using trusted certificates with your runner](https://docs.gitlab.com/runner/install/docker.html#installing-trusted-ssl-server-certificates):
```shell
sudo mkdir -p /etc/gitlab-runner/certs
sudo cp /etc/gitlab/ssl/my-host.internal.crt /etc/gitlab-runner/certs/ca.crt
```
## Enabling GitLab Runner
[Following a similar process to the steps for installing our GitLab Runner as a Docker service](https://docs.gitlab.com/runner/install/docker.html#install-the-docker-image-and-start-the-container), we must first register our runner:
```shell
$ sudo docker run --rm -it -v /etc/gitlab-runner:/etc/gitlab-runner gitlab/gitlab-runner register
Updating CA certificates...
Runtime platform arch=amd64 os=linux pid=7 revision=1b659122 version=12.8.0
Running in system-mode.
Enter the GitLab instance URL (for example, https://gitlab.com/):
https://my-host.internal
Enter the registration token:
XXXXXXXXXXX
Enter a description for the runner:
[eb18856e13c0]:
Enter tags for the runner (comma-separated):
Enter optional maintenance note for the runner:
Registering runner... succeeded runner=FSMwkvLZ
Please enter the executor: custom, docker, virtualbox, kubernetes, docker+machine, docker-ssh+machine, docker-ssh, parallels, shell, ssh:
docker
Please enter the default Docker image (for example, ruby:2.6):
ruby:2.6
Runner registered successfully. Feel free to start it, but if it's running already the config should be automatically reloaded!
```
Now we must add some additional configuration to our runner:
Make the following changes to `/etc/gitlab-runner/config.toml`:
- Add Docker socket to volumes `volumes = ["/var/run/docker.sock:/var/run/docker.sock", "/cache"]`
- Add `pull_policy = "if-not-present"` to the executor configuration
Now we can start our runner:
```shell
sudo docker run -d --restart always --name gitlab-runner -v /etc/gitlab-runner:/etc/gitlab-runner -v /var/run/docker.sock:/var/run/docker.sock gitlab/gitlab-runner:latest
90646b6587127906a4ee3f2e51454c6e1f10f26fc7a0b03d9928d8d0d5897b64
```
### Authenticating the registry against the host OS
As noted in [Docker registry authentication documentation](https://distribution.github.io/distribution/about/insecure/#docker-still-complains-about-the-certificate-when-using-authentication),
certain versions of Docker require trusting the certificate chain at the OS level.
In the case of Ubuntu, this involves using `update-ca-certificates`:
```shell
sudo cp /etc/docker/certs.d/my-host.internal\:5000/ca.crt /usr/local/share/ca-certificates/my-host.internal.crt
sudo update-ca-certificates
```
If all goes well, this is what you should see:
```plaintext
1 added, 0 removed; done.
Running hooks in /etc/ca-certificates/update.d...
done.
```
### Disable Version Check and Service Ping
Version Check and Service Ping improve the GitLab user experience and ensure that
users are on the most up-to-date instances of GitLab. These two services can be turned off for offline
environments so that they do not attempt and fail to reach out to GitLab services.
For more information, see [Enable or disable service ping](../../administration/settings/usage_statistics.md#enable-or-disable-service-ping).
### Disable runner version management
Runner version management retrieves the latest runner versions from GitLab to
[determine which runners in your environment are out of date](../../ci/runners/runners_scope.md#determine-which-runners-need-to-be-upgraded).
You must [disable runner version management](../../administration/settings/continuous_integration.md#control-runner-version-management)
for offline environments.
### Configure NTP
Gitaly Cluster (Praefect) assumes `pool.ntp.org` is accessible. If `pool.ntp.org` is not accessible, [customize the time server setting](../../administration/gitaly/praefect/configure.md#customize-time-server-setting) on the Gitaly
and Praefect servers so they can use an accessible NTP server.
On offline instances, the [GitLab Geo check Rake task](../../administration/geo/replication/troubleshooting/common.md#can-geo-detect-the-current-site-correctly)
always fails because it uses `pool.ntp.org`. This error can be ignored but you can
[read more about how to work around it](../../administration/geo/replication/troubleshooting/common.md#message-machine-clock-is-synchronized--exception).
## Enabling the Package Metadata Database
Enabling the Package Metadata Database is required to enable
[Continuous Vulnerability Scanning](../../user/application_security/continuous_vulnerability_scanning/_index.md)
and [license scanning of CycloneDX files](../../user/compliance/license_scanning_of_cyclonedx_files/_index.md).
This process requires the use of License and/or Advisory Data under what is collectively called the Package Metadata Database, which is licensed under the [EE License](https://storage.googleapis.com/prod-export-license-bucket-1a6c642fc4de57d4/LICENSE).
Note the following in relation to use of the Package Metadata Database:
- We may change or discontinue all or any part of the Package Metadata Database, at any time and without notice, at our sole discretion.
- The Package Metadata Database may contain links to third-party websites or resources. We provide these links only as a convenience and are not responsible for any third-party data, content, products, or services from those websites or resources or links displayed on such websites.
- The Package Metadata Database is based in part on information made available by third parties, and GitLab is not responsible for the accuracy or completeness of content made available.
Package metadata is stored in the following Google Cloud Provider (GCP) buckets:
- License Scanning - `prod-export-license-bucket-1a6c642fc4de57d4`
- Dependency Scanning - `prod-export-advisory-bucket-1a6c642fc4de57d4`
### Using the gsutil tool to download the package metadata exports
1. Install the [`gsutil`](https://cloud.google.com/storage/docs/gsutil_install) tool.
1. Find the root of the GitLab Rails directory.
```shell
export GITLAB_RAILS_ROOT_DIR="$(gitlab-rails runner 'puts Rails.root.to_s')"
echo $GITLAB_RAILS_ROOT_DIR
```
1. Set the type of data you wish to sync.
```shell
# For License Scanning
export PKG_METADATA_BUCKET=prod-export-license-bucket-1a6c642fc4de57d4
export DATA_DIR="licenses"
# For Dependency Scanning
export PKG_METADATA_BUCKET=prod-export-advisory-bucket-1a6c642fc4de57d4
export DATA_DIR="advisories"
```
1. Download the package metadata exports.
```shell
# To download the package metadata exports, an outbound connection to Google Cloud Storage bucket must be allowed.
mkdir -p "$GITLAB_RAILS_ROOT_DIR/vendor/package_metadata/$DATA_DIR"
gsutil -m rsync -r -d gs://$PKG_METADATA_BUCKET "$GITLAB_RAILS_ROOT_DIR/vendor/package_metadata/$DATA_DIR"
# Alternatively, if the GitLab instance is not allowed to connect to the Google Cloud Storage bucket, the package metadata
# exports can be downloaded using a machine with the allowed access, and then copied to the root of the GitLab Rails directory.
rsync rsync://example_username@gitlab.example.com/package_metadata/$DATA_DIR "$GITLAB_RAILS_ROOT_DIR/vendor/package_metadata/$DATA_DIR"
```
### Using the Google Cloud Storage REST API to download the package metadata exports
The package metadata exports can also be downloaded using the Google Cloud Storage API. The contents are available at [https://storage.googleapis.com/storage/v1/b/prod-export-license-bucket-1a6c642fc4de57d4/o](https://storage.googleapis.com/storage/v1/b/prod-export-license-bucket-1a6c642fc4de57d4/o) and [https://storage.googleapis.com/storage/v1/b/prod-export-advisory-bucket-1a6c642fc4de57d4/o](https://storage.googleapis.com/storage/v1/b/prod-export-advisory-bucket-1a6c642fc4de57d4/o). The following is an example of how this can be downloaded using [cURL](https://curl.se/) and [jq](https://stedolan.github.io/jq/).
```shell
#!/bin/bash
set -euo pipefail
DATA_TYPE=$1
GITLAB_RAILS_ROOT_DIR="$(gitlab-rails runner 'puts Rails.root.to_s')"
if [ "$DATA_TYPE" == "license" ]; then
PKG_METADATA_DIR="$GITLAB_RAILS_ROOT_DIR/vendor/package_metadata/licenses"
elif [ "$DATA_TYPE" == "advisory" ]; then
PKG_METADATA_DIR="$GITLAB_RAILS_ROOT_DIR/vendor/package_metadata/advisories"
else
echo "Usage: import_script.sh [license|advisory]"
exit 1
fi
PKG_METADATA_BUCKET="prod-export-$DATA_TYPE-bucket-1a6c642fc4de57d4"
PKG_METADATA_DOWNLOADS_OUTPUT_FILE="/tmp/package_metadata_${DATA_TYPE}_object_links.tsv"
# Download the contents of the bucket
# The script downloads all the objects and creates files with a maximum 1000 objects per file in JSON format.
MAX_RESULTS=1000
TEMP_FILE="out.json"
curl --silent --show-error --request GET "https://storage.googleapis.com/storage/v1/b/$PKG_METADATA_BUCKET/o?maxResults=$MAX_RESULTS" >"$TEMP_FILE"
NEXT_PAGE_TOKEN="$(jq -r '.nextPageToken' $TEMP_FILE)"
jq -r '.items[] | [.name, .mediaLink] | @tsv' "$TEMP_FILE" >"$PKG_METADATA_DOWNLOADS_OUTPUT_FILE"
while [ "$NEXT_PAGE_TOKEN" != "null" ]; do
curl --silent --show-error --request GET "https://storage.googleapis.com/storage/v1/b/$PKG_METADATA_BUCKET/o?maxResults=$MAX_RESULTS&pageToken=$NEXT_PAGE_TOKEN" >"$TEMP_FILE"
NEXT_PAGE_TOKEN="$(jq -r '.nextPageToken' $TEMP_FILE)"
jq -r '.items[] | [.name, .mediaLink] | @tsv' "$TEMP_FILE" >>"$PKG_METADATA_DOWNLOADS_OUTPUT_FILE"
#use for API rate-limiting
sleep 1
done
trap 'rm -f "$TEMP_FILE"' EXIT
echo "Fetched $DATA_TYPE export manifest"
# Parse the links and names for the bucket objects and output them into a tsv file
echo -e "Saving package metadata exports to $PKG_METADATA_DIR\n"
# Track how many objects will be downloaded
INDEX=1
TOTAL_OBJECT_COUNT="$(wc -l "$PKG_METADATA_DOWNLOADS_OUTPUT_FILE" | awk '{print $1}')"
# Download the objects
while IFS= read -r line; do
FILE="$(echo -n "$line" | awk '{print $1}')"
URL="$(echo -n "$line" | awk '{print $2}')"
OUTPUT_PATH="$PKG_METADATA_DIR/$FILE"
echo "Downloading $FILE"
if [ ! -f "$OUTPUT_PATH" ]; then
curl --progress-bar --create-dirs --output "$OUTPUT_PATH" --request "GET" "$URL"
else
echo "Existing file found"
fi
echo -e "$INDEX of $TOTAL_OBJECT_COUNT objects downloaded\n"
INDEX=$((INDEX + 1))
done <"$PKG_METADATA_DOWNLOADS_OUTPUT_FILE"
echo "All objects saved to $PKG_METADATA_DIR"
```
### Automatic synchronization
Your GitLab instance is synchronized [regularly](https://gitlab.com/gitlab-org/gitlab/-/blob/63a187d47f6da353ba4514650bbbbeb99c356325/config/initializers/1_settings.rb#L840-842) with the contents of the `package_metadata` directory.
To automatically update your local copy with the upstream changes, a cron job can be added to periodically download new exports. For example, the following crontabs can be added to set up a cron job that runs every 30 minutes.
For License Scanning:
```plaintext
*/30 * * * * gsutil -m rsync -r -d -y "^v1\/" gs://prod-export-license-bucket-1a6c642fc4de57d4 $GITLAB_RAILS_ROOT_DIR/vendor/package_metadata/licenses
```
For Dependency Scanning:
```plaintext
*/30 * * * * gsutil -m rsync -r -d gs://prod-export-advisory-bucket-1a6c642fc4de57d4 $GITLAB_RAILS_ROOT_DIR/vendor/package_metadata/advisories
```
### Change note
The directory for package metadata changed with the release of 16.2 from `vendor/package_metadata_db` to `vendor/package_metadata/licenses`. If this directory already exists on the instance and Dependency Scanning needs to be added then you need to take the following steps.
1. Rename the licenses directory: `mv vendor/package_metadata_db vendor/package_metadata/licenses`.
1. Update any automation scripts or commands saved to change `vendor/package_metadata_db` to `vendor/package_metadata/licenses`.
1. Update any cron entries to change `vendor/package_metadata_db` to `vendor/package_metadata/licenses`.
```shell
sed -i '.bckup' -e 's#vendor/package_metadata_db#vendor/package_metadata/licenses#g' [FILE ...]
```
### Troubleshooting
#### Missing database data
If license or advisory data is missing from the dependency list or MR pages, one possible cause of this is that the database has not been synchronized with the export data.
`package_metadata` synchronization is triggered by using cron jobs ([advisory sync](https://gitlab.com/gitlab-org/gitlab/-/blob/16-3-stable-ee/config/initializers/1_settings.rb#L864-866) and [license sync](https://gitlab.com/gitlab-org/gitlab/-/blob/16-3-stable-ee/config/initializers/1_settings.rb#L855-857)) and imports only the package registry types enabled in [admin settings](../../administration/settings/security_and_compliance.md#choose-package-registry-metadata-to-sync).
The file structure in `vendor/package_metadata` must coincide with the package registry type enabled previously. For example, to sync `maven` license or advisory data, the package metadata directory under the Rails directory must have the following structure:
- For licenses:`$GITLAB_RAILS_ROOT_DIR/vendor/package_metadata/licenses/v2/maven/**/*.ndjson`.
- For advisories:`$GITLAB_RAILS_ROOT_DIR/vendor/package_metadata/advisories/v2/maven/**/*.ndjson`.
After a successful run, data under the `pm_` tables in the database should be populated (check using [Rails console](../../administration/operations/rails_console.md)):
- For licenses: `sudo gitlab-rails runner "puts \"Package model has #{PackageMetadata::Package.where(purl_type: 'maven').size} packages\""`
- For advisories: `sudo gitlab-rails runner "puts \"Advisory model has #{PackageMetadata::AffectedPackage.where(purl_type: 'maven').size} packages\""`
Additionally, checkpoint data should exist for the particular package registry being synchronized. For Maven, for example, there should be a checkpoint created after a successful sync run:
- For licenses: `sudo gitlab-rails runner "puts \"maven data has been synced up to #{PackageMetadata::Checkpoint.where(data_type: 'licenses', purl_type: 'maven')}\""`
- For advisories: `sudo gitlab-rails runner "puts \"maven data has been synced up to #{PackageMetadata::Checkpoint.where(data_type: 'advisories', purl_type: 'maven')}\""`
Finally, you can check the [`application_json.log`](../../administration/logs/_index.md#application_jsonlog) logs to verify that the
sync job has run and is without error by searching for `DEBUG` messages where the class is `PackageMetadata::SyncService`. Example: `{"severity":"DEBUG","time":"2023-06-22T16:41:00.825Z","correlation_id":"a6e80150836b4bb317313a3fe6d0bbd6","class":"PackageMetadata::SyncService","message":"Evaluating data for licenses:gcp/prod-export-license-bucket-1a6c642fc4de57d4/v2/pypi/1694703741/0.ndjson"}`.
|
https://docs.gitlab.com/topics/offline
|
https://gitlab.com/gitlab-org/gitlab/-/tree/master/doc/topics/_index.md
|
2025-08-13
|
doc/topics/offline
|
[
"doc",
"topics",
"offline"
] |
_index.md
|
GitLab Delivery
|
Self Managed
|
To determine the technical writer assigned to the Stage/Group associated with this page, see https://handbook.gitlab.com/handbook/product/ux/technical-writing/#assignments
|
Offline GitLab
|
Isolated installation.
|
{{< details >}}
- Tier: Free, Premium, Ultimate
- Offering: GitLab Self-Managed
{{< /details >}}
Computers in an offline environment are isolated from the public internet as a security measure. This
page lists all the information available for running GitLab in an offline environment.
## Quick start
If you plan to deploy a GitLab instance on a physically-isolated and offline network, see the
[quick start guide](quick_start_guide.md) for configuration steps.
## Features
Follow these best practices to use GitLab features in an offline environment:
- [Operating the GitLab Secure scanners in an offline environment](../../user/application_security/offline_deployments/_index.md).
|
---
stage: GitLab Delivery
group: Self Managed
info: To determine the technical writer assigned to the Stage/Group associated with
this page, see https://handbook.gitlab.com/handbook/product/ux/technical-writing/#assignments
description: Isolated installation.
title: Offline GitLab
breadcrumbs:
- doc
- topics
- offline
---
{{< details >}}
- Tier: Free, Premium, Ultimate
- Offering: GitLab Self-Managed
{{< /details >}}
Computers in an offline environment are isolated from the public internet as a security measure. This
page lists all the information available for running GitLab in an offline environment.
## Quick start
If you plan to deploy a GitLab instance on a physically-isolated and offline network, see the
[quick start guide](quick_start_guide.md) for configuration steps.
## Features
Follow these best practices to use GitLab features in an offline environment:
- [Operating the GitLab Secure scanners in an offline environment](../../user/application_security/offline_deployments/_index.md).
|
https://docs.gitlab.com/bronze_starter
|
https://gitlab.com/gitlab-org/gitlab/-/tree/master/doc/bronze_starter.md
|
2025-08-13
|
doc/subscriptions
|
[
"doc",
"subscriptions"
] |
bronze_starter.md
| null | null | null | null | null |
<!-- markdownlint-disable -->
This document was moved to [another location](_index.md).
<!-- This redirect file can be deleted after <2025-09-25>. -->
<!-- Redirects that point to other docs in the same project expire in three months. -->
<!-- Redirects that point to docs in a different project or site (for example, link is not relative and starts with `https:`) expire in one year. -->
<!-- Before deletion, see: https://docs.gitlab.com/development/documentation/redirects -->
|
---
redirect_to: _index.md
remove_date: '2025-09-25'
breadcrumbs:
- doc
- subscriptions
---
<!-- markdownlint-disable -->
This document was moved to [another location](_index.md).
<!-- This redirect file can be deleted after <2025-09-25>. -->
<!-- Redirects that point to other docs in the same project expire in three months. -->
<!-- Redirects that point to docs in a different project or site (for example, link is not relative and starts with `https:`) expire in one year. -->
<!-- Before deletion, see: https://docs.gitlab.com/development/documentation/redirects -->
|
https://docs.gitlab.com/customers_portal
|
https://gitlab.com/gitlab-org/gitlab/-/tree/master/doc/customers_portal.md
|
2025-08-13
|
doc/subscriptions
|
[
"doc",
"subscriptions"
] |
customers_portal.md
|
Fulfillment
|
Subscription Management
|
To determine the technical writer assigned to the Stage/Group associated with this page, see https://handbook.gitlab.com/handbook/product/ux/technical-writing/#assignments
|
The Customers Portal
|
Customers Portal is a comprehensive self-service hub for purchasing and managing GitLab subscriptions and billing.
|
The Customers Portal is your comprehensive self-service hub for managing GitLab subscriptions and billing. You can purchase GitLab products, manage your subscriptions throughout the entire subscription lifecycle, view and pay invoices, and access your billing details and contact information.
See the following pages for specific instructions on managing your subscription:
- [GitLab SaaS subscription](gitlab_com/_index.md)
- [GitLab Self-Managed subscription](self_managed/_index.md)
- [Manage subscription](manage_subscription.md)
If you made your purchase through an authorized reseller, you must contact them directly to make changes to your subscription.
For more information, see [Customers that purchased through a reseller](#subscription-purchased-through-a-reseller).
## Sign in to Customers Portal
You can sign in to Customers Portal either with your GitLab.com account or a one-time sign-in link sent to your email (if you have not yet [linked your Customers Portal account to your GitLab.com account](#link-a-gitlabcom-account)).
{{< alert type="note" >}}
If you registered for Customers Portal with your GitLab.com account, sign in with this account.
{{< /alert >}}
To sign in to Customers Portal using your GitLab.com account:
1. Go to [Customers Portal](https://customers.gitlab.com/customers/sign_in).
1. Select **Continue with GitLab.com account**.
To sign in to Customers Portal with your email and to receive a one-time sign-in link:
1. Go to [Customers Portal](https://customers.gitlab.com/customers/sign_in).
1. Select **Sign in with your email**.
1. Provide the **Email** for your Customers Portal profile. You will receive an email with a one-time sign-in link.
1. In the email you received, select **Sign in**.
{{< alert type="note" >}}
The one-time sign-in link expires in 24 hours and can only be used once.
{{< /alert >}}
## Confirm Customers Portal email address
The first time you sign in to the Customers Portal with a one-time sign-in link,
you must confirm your email address to maintain access to the Customers Portal. If you sign in
to the Customers Portal through GitLab.com, you don't need to confirm your email address.
You must also confirm any updates to the profile email address. You will receive
an automatic email with instructions about how to confirm, which you can [resend](https://customers.gitlab.com/customers/confirmation/new)
if required.
## Change profile owner information
The profile owner's email address is used for the [Customers Portal legacy sign-in](#sign-in-to-customers-portal).
If the profile owner is also a [billing account manager](#subscription-and-billing-contacts),
their personal details are used on invoices, and for license and subscription-related emails.
To change profile details, including name and email address:
1. Sign in to the [Customers Portal](https://customers.gitlab.com/customers/sign_in).
1. Select **My profile > Profile settings**.
1. Edit **Your personal details**.
1. Select **Save changes**.
You can also [transfer ownership of the Customers Portal profile and billing account](https://support.gitlab.com/hc/en-us/articles/17767356437148-How-to-transfer-subscription-ownership) to another person.
## Change your company details
To change your company details, including company name and tax ID:
1. Sign in to the [Customers Portal](https://customers.gitlab.com/customers/sign_in).
1. Select **Billing account settings**.
1. Scroll down to the **Company information** section.
1. Edit the company details.
1. Select **Save changes**.
## Subscription and billing contacts
### Change your subscription contact
The subscription contact is the primary contact for your billing account. They receive subscription event notifications and information about applying subscription.
To change the subscription contact:
1. Sign in to the [Customers Portal](https://customers.gitlab.com/customers/sign_in).
1. On the left sidebar, select **Billing account settings**.
1. Scroll to the **Company information** section, then to **Subscription contact**.
1. To select a different subscription contact, select from the **Billing account manager** dropdown list.
1. Edit the contact details.
1. Select **Save changes**.
### Add a billing account manager
Billing account managers can view and edit subscriptions, payment methods, and account settings, as well as pay and download invoices.
To add another billing account manager for your account:
1. Ensure an account exists in the [Customers Portal](https://customers.gitlab.com/customers/sign_in) for the user you want to add.
1. Sign in to the [Customers Portal](https://customers.gitlab.com/customers/sign_in).
1. On the left sidebar, select **Billing account settings**.
1. Scroll to the **Billing account managers** section.
1. Select **Invite billing account manager**.
1. Enter the email address of the user you want to add.
1. Select **Invite**.
The invited user receives an email with an invitation to the Customers Portal.
The invitation is valid for seven days.
If the user does not accept the invitation before it expires, you can send them a new invitation.
You can have maximum 15 pending invitations at a time.
### Remove a billing account manager
You can remove billing account managers from your account at any time.
After you remove a billing account manager, they no longer have access to view or edit your billing account information.
To remove a billing account manager:
1. Sign in to the [Customers Portal](https://customers.gitlab.com/customers/sign_in).
1. On the left sidebar, select **Billing account settings**.
1. Scroll to the **Billing account managers** section.
1. In the list, next to the billing account manager you want to remove, select **Remove**.
1. In the confirmation dialog, select **Remove** to confirm the action.
### Revoke a billing account manager invitation
You can revoke invitations that have not yet been accepted.
Users that have been invited but have not yet accepted the invitation display the name **Awaiting user registration**.
To revoke an invitation:
1. Sign in to the [Customers Portal](https://customers.gitlab.com/customers/sign_in).
1. On the left sidebar, select **Billing account settings**.
1. Scroll to the **Billing account managers** section.
1. In the list, next to the invited user with the **Awaiting user registration** name, select **Remove**.
1. In the confirmation dialog, select **Remove** to revoke the invitation.
### Change your billing contact
The billing contact receives all invoices and subscription event notifications.
To change the billing contact:
1. Sign in to the [Customers Portal](https://customers.gitlab.com/customers/sign_in).
1. On the left sidebar, select **Billing account settings**.
1. Scroll to the **Company information** section, then to **Billing contact**.
- To change your billing contact to your subscription contact:
1. Select **Billing contact is the same as subscription contact**.
1. Select **Save changes**.
- To change your billing contact to a different billing account manager:
1. Clear the **Billing contact is the same as subscription contact** checkbox.
1. Select a different billing account manager from the **User** dropdown list.
1. Edit the contact details.
1. Select **Save changes**.
- To change your billing contact to a custom contact:
1. Clear the **Billing contact is the same as subscription contact** checkbox.
1. Select **Enter a custom contact** from the **User** dropdown list.
1. Enter the contact details.
1. Select **Save changes**.
## Change your payment method
Purchases in the Customers Portal require a credit card on record as a payment method. You can add
multiple credit cards to your account, so that purchases for different products are charged to the
correct card.
If you would like to use an alternative method to pay,
[contact our Sales team](https://customers.gitlab.com/contact_us).
To change your payment method:
1. Sign in to the [Customers Portal](https://customers.gitlab.com/customers/sign_in).
1. On the left sidebar, select **Billing account settings**.
1. **Edit** an existing payment method's information or **Add new payment method**.
1. Select **Save Changes**.
### Set a default payment method
Automatic renewal of a subscription is charged to your default payment method. To mark a payment
method as the default:
1. Sign in to the [Customers Portal](https://customers.gitlab.com/customers/sign_in).
1. On the left sidebar, select **Billing account settings**.
1. **Edit** the selected payment method and check the **Make default payment method** checkbox.
1. Select **Save Changes**.
### Delete a default payment method
You cannot delete your default payment method directly through the Customers Portal. To delete a default payment method, [contact our Billing team](https://customers.gitlab.com/contact_us) for assistance.
## Pay for an invoice
You can pay for your invoices in the Customers Portal with a credit card.
To pay for an invoice:
1. Sign in to the [Customers Portal](https://customers.gitlab.com/customers/sign_in).
1. On the left sidebar, select **Invoices**.
1. On the invoice you want to pay for, select **Pay for invoice**.
1. Complete the payment form.
If you would like to use an alternative payment method,
[contact our Billing team](https://customers.gitlab.com/contact_us#contact-billing-team).
## Link a GitLab.com account
Follow this guideline if you have a legacy Customers Portal profile to sign in.
To link a GitLab.com account to your Customers Portal profile:
1. Trigger a one-time sign-in link to your email from the [Customers Portal](https://customers.gitlab.com/customers/sign_in?legacy=true).
1. Locate the email and click on the one-time sign-in link to sign in to your Customers Portal account.
1. Select **My profile > Profile settings**.
1. Under **Your GitLab.com account**, select **Link account**.
1. Sign in to the [GitLab.com](https://gitlab.com/users/sign_in) account you want to link to the Customers Portal profile.
## Change the linked account
If you want to link your Customers Portal account to a different GitLab.com account,
you must use your GitLab.com account to register for a new Customers Portal profile.
If you want to change subscription contacts, you can instead do either of the following:
- [Change the billing contact](#change-your-billing-contact).
- [Change the subscription contact](#change-your-subscription-contact).
If you have a legacy Customers Portal profile that is not linked to a GitLab.com account, you may still [sign in](https://customers.gitlab.com/customers/sign_in?legacy=true) using a one-time sign-in link sent to your email. However, you should [create](https://gitlab.com/users/sign_up) and [link a GitLab.com account](#change-the-linked-account) to ensure continued access to the Customers Portal.
To change the GitLab.com account linked to your Customers Portal profile:
1. Sign in to the [Customers Portal](https://customers.gitlab.com/customers/sign_in).
1. In a separate browser tab, go to [GitLab.com](https://gitlab.com/users/sign_in) and ensure you are not logged in.
1. On the Customers Portal page, select **My profile > Profile settings**.
1. Under **Your GitLab.com account**, select **Change linked account**.
1. Sign in to the [GitLab.com](https://gitlab.com/users/sign_in) account you want to link to the Customers Portal profile.
## Tax ID for non-US customers
A Tax ID is a unique number assigned by tax authorities to businesses registered for Value Added Tax (VAT), Goods and Services Tax (GST), or similar indirect taxes.
Providing a valid Tax ID may reduce your tax burden by allowing us to apply reverse charge mechanisms instead of charging VAT/GST on your invoices. Without a valid Tax ID, we charge applicable VAT/GST rates based on your location.
If your business isn't registered for indirect taxes (due to size thresholds or other reasons), we apply the standard VAT/GST rate according to local regulations.
For detailed Tax ID formats by country and additional information, see our [complete Tax ID reference guide](https://handbook.gitlab.com/handbook/finance/tax/#frequently-asked-questions---tax-id-for-non-us-customers).
## Troubleshooting
If you encounter issues or have questions about your GitLab subscription,
visit the [Contact us](https://customers.gitlab.com/contact_us) page.
This page lists resources, services, and contact options of the sales, billing, and support teams,
which ensures quick access to the right help.
### Subscription purchased through a reseller
If you purchased a subscription through an authorized reseller (including GCP and AWS marketplaces), you have access to the Customers Portal to:
- View your subscription.
- Associate your subscription with the relevant group (GitLab.com) or download the license (GitLab Self-Managed).
- Manage contact information.
Other changes and requests must be done through the reseller, including:
- Changes to the subscription.
- Purchase of additional seats, Storage, or Compute.
- Requests for invoices, because those are issued by the reseller, not GitLab.
Resellers do not have access to the Customers Portal, or their customers' accounts.
After your subscription order is processed, you will receive several emails:
- A "Welcome to the Customers Portal" email, including instructions on how to sign in.
- A purchase confirmation email with instructions on how to provision access.
### Billing and subscription contact's names don't match
If the billing account manager's email is linked to contacts with different first or last names,
you will be prompted to update the name.
If you are the billing account manager, follow the instructions to [update your personal profile](#change-profile-owner-information).
If you are not the billing account manager, notify them to update their personal profile.
### Subscription contact is no longer account manager
If the subscription contact is no longer a billing account manager, you will be prompted to select a new contact.
Follow the instructions to [change your subscription contact](#change-your-subscription-contact).
|
---
stage: Fulfillment
group: Subscription Management
info: To determine the technical writer assigned to the Stage/Group associated with
this page, see https://handbook.gitlab.com/handbook/product/ux/technical-writing/#assignments
description: Customers Portal is a comprehensive self-service hub for purchasing and
managing GitLab subscriptions and billing.
title: The Customers Portal
breadcrumbs:
- doc
- subscriptions
---
The Customers Portal is your comprehensive self-service hub for managing GitLab subscriptions and billing. You can purchase GitLab products, manage your subscriptions throughout the entire subscription lifecycle, view and pay invoices, and access your billing details and contact information.
See the following pages for specific instructions on managing your subscription:
- [GitLab SaaS subscription](gitlab_com/_index.md)
- [GitLab Self-Managed subscription](self_managed/_index.md)
- [Manage subscription](manage_subscription.md)
If you made your purchase through an authorized reseller, you must contact them directly to make changes to your subscription.
For more information, see [Customers that purchased through a reseller](#subscription-purchased-through-a-reseller).
## Sign in to Customers Portal
You can sign in to Customers Portal either with your GitLab.com account or a one-time sign-in link sent to your email (if you have not yet [linked your Customers Portal account to your GitLab.com account](#link-a-gitlabcom-account)).
{{< alert type="note" >}}
If you registered for Customers Portal with your GitLab.com account, sign in with this account.
{{< /alert >}}
To sign in to Customers Portal using your GitLab.com account:
1. Go to [Customers Portal](https://customers.gitlab.com/customers/sign_in).
1. Select **Continue with GitLab.com account**.
To sign in to Customers Portal with your email and to receive a one-time sign-in link:
1. Go to [Customers Portal](https://customers.gitlab.com/customers/sign_in).
1. Select **Sign in with your email**.
1. Provide the **Email** for your Customers Portal profile. You will receive an email with a one-time sign-in link.
1. In the email you received, select **Sign in**.
{{< alert type="note" >}}
The one-time sign-in link expires in 24 hours and can only be used once.
{{< /alert >}}
## Confirm Customers Portal email address
The first time you sign in to the Customers Portal with a one-time sign-in link,
you must confirm your email address to maintain access to the Customers Portal. If you sign in
to the Customers Portal through GitLab.com, you don't need to confirm your email address.
You must also confirm any updates to the profile email address. You will receive
an automatic email with instructions about how to confirm, which you can [resend](https://customers.gitlab.com/customers/confirmation/new)
if required.
## Change profile owner information
The profile owner's email address is used for the [Customers Portal legacy sign-in](#sign-in-to-customers-portal).
If the profile owner is also a [billing account manager](#subscription-and-billing-contacts),
their personal details are used on invoices, and for license and subscription-related emails.
To change profile details, including name and email address:
1. Sign in to the [Customers Portal](https://customers.gitlab.com/customers/sign_in).
1. Select **My profile > Profile settings**.
1. Edit **Your personal details**.
1. Select **Save changes**.
You can also [transfer ownership of the Customers Portal profile and billing account](https://support.gitlab.com/hc/en-us/articles/17767356437148-How-to-transfer-subscription-ownership) to another person.
## Change your company details
To change your company details, including company name and tax ID:
1. Sign in to the [Customers Portal](https://customers.gitlab.com/customers/sign_in).
1. Select **Billing account settings**.
1. Scroll down to the **Company information** section.
1. Edit the company details.
1. Select **Save changes**.
## Subscription and billing contacts
### Change your subscription contact
The subscription contact is the primary contact for your billing account. They receive subscription event notifications and information about applying subscription.
To change the subscription contact:
1. Sign in to the [Customers Portal](https://customers.gitlab.com/customers/sign_in).
1. On the left sidebar, select **Billing account settings**.
1. Scroll to the **Company information** section, then to **Subscription contact**.
1. To select a different subscription contact, select from the **Billing account manager** dropdown list.
1. Edit the contact details.
1. Select **Save changes**.
### Add a billing account manager
Billing account managers can view and edit subscriptions, payment methods, and account settings, as well as pay and download invoices.
To add another billing account manager for your account:
1. Ensure an account exists in the [Customers Portal](https://customers.gitlab.com/customers/sign_in) for the user you want to add.
1. Sign in to the [Customers Portal](https://customers.gitlab.com/customers/sign_in).
1. On the left sidebar, select **Billing account settings**.
1. Scroll to the **Billing account managers** section.
1. Select **Invite billing account manager**.
1. Enter the email address of the user you want to add.
1. Select **Invite**.
The invited user receives an email with an invitation to the Customers Portal.
The invitation is valid for seven days.
If the user does not accept the invitation before it expires, you can send them a new invitation.
You can have maximum 15 pending invitations at a time.
### Remove a billing account manager
You can remove billing account managers from your account at any time.
After you remove a billing account manager, they no longer have access to view or edit your billing account information.
To remove a billing account manager:
1. Sign in to the [Customers Portal](https://customers.gitlab.com/customers/sign_in).
1. On the left sidebar, select **Billing account settings**.
1. Scroll to the **Billing account managers** section.
1. In the list, next to the billing account manager you want to remove, select **Remove**.
1. In the confirmation dialog, select **Remove** to confirm the action.
### Revoke a billing account manager invitation
You can revoke invitations that have not yet been accepted.
Users that have been invited but have not yet accepted the invitation display the name **Awaiting user registration**.
To revoke an invitation:
1. Sign in to the [Customers Portal](https://customers.gitlab.com/customers/sign_in).
1. On the left sidebar, select **Billing account settings**.
1. Scroll to the **Billing account managers** section.
1. In the list, next to the invited user with the **Awaiting user registration** name, select **Remove**.
1. In the confirmation dialog, select **Remove** to revoke the invitation.
### Change your billing contact
The billing contact receives all invoices and subscription event notifications.
To change the billing contact:
1. Sign in to the [Customers Portal](https://customers.gitlab.com/customers/sign_in).
1. On the left sidebar, select **Billing account settings**.
1. Scroll to the **Company information** section, then to **Billing contact**.
- To change your billing contact to your subscription contact:
1. Select **Billing contact is the same as subscription contact**.
1. Select **Save changes**.
- To change your billing contact to a different billing account manager:
1. Clear the **Billing contact is the same as subscription contact** checkbox.
1. Select a different billing account manager from the **User** dropdown list.
1. Edit the contact details.
1. Select **Save changes**.
- To change your billing contact to a custom contact:
1. Clear the **Billing contact is the same as subscription contact** checkbox.
1. Select **Enter a custom contact** from the **User** dropdown list.
1. Enter the contact details.
1. Select **Save changes**.
## Change your payment method
Purchases in the Customers Portal require a credit card on record as a payment method. You can add
multiple credit cards to your account, so that purchases for different products are charged to the
correct card.
If you would like to use an alternative method to pay,
[contact our Sales team](https://customers.gitlab.com/contact_us).
To change your payment method:
1. Sign in to the [Customers Portal](https://customers.gitlab.com/customers/sign_in).
1. On the left sidebar, select **Billing account settings**.
1. **Edit** an existing payment method's information or **Add new payment method**.
1. Select **Save Changes**.
### Set a default payment method
Automatic renewal of a subscription is charged to your default payment method. To mark a payment
method as the default:
1. Sign in to the [Customers Portal](https://customers.gitlab.com/customers/sign_in).
1. On the left sidebar, select **Billing account settings**.
1. **Edit** the selected payment method and check the **Make default payment method** checkbox.
1. Select **Save Changes**.
### Delete a default payment method
You cannot delete your default payment method directly through the Customers Portal. To delete a default payment method, [contact our Billing team](https://customers.gitlab.com/contact_us) for assistance.
## Pay for an invoice
You can pay for your invoices in the Customers Portal with a credit card.
To pay for an invoice:
1. Sign in to the [Customers Portal](https://customers.gitlab.com/customers/sign_in).
1. On the left sidebar, select **Invoices**.
1. On the invoice you want to pay for, select **Pay for invoice**.
1. Complete the payment form.
If you would like to use an alternative payment method,
[contact our Billing team](https://customers.gitlab.com/contact_us#contact-billing-team).
## Link a GitLab.com account
Follow this guideline if you have a legacy Customers Portal profile to sign in.
To link a GitLab.com account to your Customers Portal profile:
1. Trigger a one-time sign-in link to your email from the [Customers Portal](https://customers.gitlab.com/customers/sign_in?legacy=true).
1. Locate the email and click on the one-time sign-in link to sign in to your Customers Portal account.
1. Select **My profile > Profile settings**.
1. Under **Your GitLab.com account**, select **Link account**.
1. Sign in to the [GitLab.com](https://gitlab.com/users/sign_in) account you want to link to the Customers Portal profile.
## Change the linked account
If you want to link your Customers Portal account to a different GitLab.com account,
you must use your GitLab.com account to register for a new Customers Portal profile.
If you want to change subscription contacts, you can instead do either of the following:
- [Change the billing contact](#change-your-billing-contact).
- [Change the subscription contact](#change-your-subscription-contact).
If you have a legacy Customers Portal profile that is not linked to a GitLab.com account, you may still [sign in](https://customers.gitlab.com/customers/sign_in?legacy=true) using a one-time sign-in link sent to your email. However, you should [create](https://gitlab.com/users/sign_up) and [link a GitLab.com account](#change-the-linked-account) to ensure continued access to the Customers Portal.
To change the GitLab.com account linked to your Customers Portal profile:
1. Sign in to the [Customers Portal](https://customers.gitlab.com/customers/sign_in).
1. In a separate browser tab, go to [GitLab.com](https://gitlab.com/users/sign_in) and ensure you are not logged in.
1. On the Customers Portal page, select **My profile > Profile settings**.
1. Under **Your GitLab.com account**, select **Change linked account**.
1. Sign in to the [GitLab.com](https://gitlab.com/users/sign_in) account you want to link to the Customers Portal profile.
## Tax ID for non-US customers
A Tax ID is a unique number assigned by tax authorities to businesses registered for Value Added Tax (VAT), Goods and Services Tax (GST), or similar indirect taxes.
Providing a valid Tax ID may reduce your tax burden by allowing us to apply reverse charge mechanisms instead of charging VAT/GST on your invoices. Without a valid Tax ID, we charge applicable VAT/GST rates based on your location.
If your business isn't registered for indirect taxes (due to size thresholds or other reasons), we apply the standard VAT/GST rate according to local regulations.
For detailed Tax ID formats by country and additional information, see our [complete Tax ID reference guide](https://handbook.gitlab.com/handbook/finance/tax/#frequently-asked-questions---tax-id-for-non-us-customers).
## Troubleshooting
If you encounter issues or have questions about your GitLab subscription,
visit the [Contact us](https://customers.gitlab.com/contact_us) page.
This page lists resources, services, and contact options of the sales, billing, and support teams,
which ensures quick access to the right help.
### Subscription purchased through a reseller
If you purchased a subscription through an authorized reseller (including GCP and AWS marketplaces), you have access to the Customers Portal to:
- View your subscription.
- Associate your subscription with the relevant group (GitLab.com) or download the license (GitLab Self-Managed).
- Manage contact information.
Other changes and requests must be done through the reseller, including:
- Changes to the subscription.
- Purchase of additional seats, Storage, or Compute.
- Requests for invoices, because those are issued by the reseller, not GitLab.
Resellers do not have access to the Customers Portal, or their customers' accounts.
After your subscription order is processed, you will receive several emails:
- A "Welcome to the Customers Portal" email, including instructions on how to sign in.
- A purchase confirmation email with instructions on how to provision access.
### Billing and subscription contact's names don't match
If the billing account manager's email is linked to contacts with different first or last names,
you will be prompted to update the name.
If you are the billing account manager, follow the instructions to [update your personal profile](#change-profile-owner-information).
If you are not the billing account manager, notify them to update their personal profile.
### Subscription contact is no longer account manager
If the subscription contact is no longer a billing account manager, you will be prompted to select a new contact.
Follow the instructions to [change your subscription contact](#change-your-subscription-contact).
|
https://docs.gitlab.com/gitlab_duo_trials
|
https://gitlab.com/gitlab-org/gitlab/-/tree/master/doc/gitlab_duo_trials.md
|
2025-08-13
|
doc/subscriptions
|
[
"doc",
"subscriptions"
] |
gitlab_duo_trials.md
|
Fulfillment
|
Provision
|
To determine the technical writer assigned to the Stage/Group associated with this page, see https://handbook.gitlab.com/handbook/product/ux/technical-writing/#assignments
|
GitLab Duo trials
|
Seat assignment, GitLab Duo subscription add-on.
|
{{< details >}}
- Tier: Premium, Ultimate
- Offering: GitLab.com, GitLab Self-Managed, GitLab Dedicated
{{< /details >}}
To try GitLab Duo, you can get access for a limited time with a free trial.
During the trial period, you'll have access to the full feature set for whichever add-on you chose.
When the trial period is over, to maintain your access, you can purchase the add-on.
Trials of the GitLab Duo add-ons last 30 days.
## Start GitLab Duo Pro trial
Get a trial of GitLab Duo Pro to test the [GitLab Duo Pro features](../user/gitlab_duo/feature_summary.md)
for a limited time.
You can get a trial of GitLab Duo Pro if you have the Premium tier on GitLab.com, GitLab Self-Managed, or GitLab Dedicated.
### On GitLab.com
Prerequisites:
- You must have the Owner role for a top-level group that has an active paid Premium subscription. Indirect ownership through group membership is not sufficient.
To start a GitLab Duo Pro trial on GitLab.com:
1. On the left sidebar, select **Search or go to** and find your group.
1. Select **Settings > Billing**.
1. Select **Start a free GitLab Duo Pro trial**.
1. Complete the fields.
1. Select **Continue**.
1. If prompted, select the group that the trial should be applied to.
1. Select **Activate my trial**.
1. [Assign seats](subscription-add-ons.md#assign-gitlab-duo-seats) to the users who need access.
### On GitLab Self-Managed
Prerequisites:
- You must have an active paid Premium subscription.
- You must have GitLab 16.8 or later and your instance must be able to [synchronize your subscription data](manage_subscription.md#subscription-data-synchronization) with GitLab.
- GitLab Duo requires GitLab 17.2 and later for the best user experience and results. Earlier versions might continue to work, however the experience may be degraded.
To start a GitLab Duo Pro trial on GitLab Self-Managed or GitLab Dedicated:
1. Go to the [GitLab Duo Pro trial page](https://about.gitlab.com/solutions/gitlab-duo-pro/sales/?toggle=gitlab-duo-pro).
1. Complete the fields.
- To find your subscription name:
1. In the Customers Portal, on the **Subscriptions & purchases** page, find the subscription you want to apply the trial to.
1. At the top of the page, the subscription name appears in a badge.
- Ensure the email address you submit for trial registration matches the email address of the [subscription contact](customers_portal.md#change-your-subscription-contact).
1. Select **Submit**.
The trial automatically synchronizes to your instance within 24 hours. After the trial has synchronized, [assign seats](subscription-add-ons.md#assign-gitlab-duo-seats) to users that you want to access GitLab Duo.
### On GitLab Dedicated
Reach out to your Sales contact if you are interested in a trial.
## Start GitLab Duo Enterprise trial
Get a trial of GitLab Duo Enterprise to test the [GitLab Duo Enterprise features](../user/gitlab_duo/feature_summary.md)
for a limited time.
You can get a trial of GitLab Duo Enterprise if:
- You have the Free tier on GitLab.com. In that case, you can try Ultimate tier with GitLab Duo Enterprise.
- You have the Premium or Ultimate tier on GitLab.com, GitLab Self-Managed, or GitLab Dedicated.
If you have the Free tier on GitLab Self-Managed, no trial is available.
### On GitLab.com
Prerequisites:
- You must have the Owner role for a top-level group that has an active paid Ultimate subscription.
To start a GitLab Duo Enterprise trial on GitLab.com:
1. On the left sidebar, select **Search or go to** and find your group.
1. Select **Settings > Billing**.
1. Select **Start a free GitLab Duo Enterprise trial**.
1. Complete the fields.
1. Select **Continue**.
1. If prompted, select the group that the trial should be applied to.
1. Select **Activate my trial**.
1. [Assign seats](subscription-add-ons.md#assign-gitlab-duo-seats) to the users who need access.
### On GitLab Self-Managed
Prerequisites:
- You must have an active paid Ultimate subscription.
- You must have GitLab 17.3 or later and your instance must be able to [synchronize your subscription data](manage_subscription.md#subscription-data-synchronization) with GitLab.
To start a GitLab Duo Enterprise trial on GitLab Self-Managed or GitLab Dedicated:
1. Go to the [GitLab Duo Enterprise trial page](https://about.gitlab.com/solutions/gitlab-duo-pro/sales/?toggle=gitlab-duo-enterprise).
1. Complete the fields.
- To find your subscription name:
1. In the Customers Portal, on the **Subscriptions & purchases** page, find the subscription you want to apply the trial to.
1. At the top of the page, the subscription name appears in a badge.
- Ensure the email address you submit for trial registration matches the email address of the [subscription contact](customers_portal.md#change-your-subscription-contact).
1. Select **Submit**.
The trial automatically synchronizes to your instance within 24 hours. After the trial has synchronized, [assign seats](subscription-add-ons.md#assign-gitlab-duo-seats) to users that you want to access GitLab Duo.
### On GitLab Dedicated
Reach out to your Sales contact if you are interested in a trial.
|
---
stage: Fulfillment
group: Provision
info: To determine the technical writer assigned to the Stage/Group associated with
this page, see https://handbook.gitlab.com/handbook/product/ux/technical-writing/#assignments
description: Seat assignment, GitLab Duo subscription add-on.
title: GitLab Duo trials
breadcrumbs:
- doc
- subscriptions
---
{{< details >}}
- Tier: Premium, Ultimate
- Offering: GitLab.com, GitLab Self-Managed, GitLab Dedicated
{{< /details >}}
To try GitLab Duo, you can get access for a limited time with a free trial.
During the trial period, you'll have access to the full feature set for whichever add-on you chose.
When the trial period is over, to maintain your access, you can purchase the add-on.
Trials of the GitLab Duo add-ons last 30 days.
## Start GitLab Duo Pro trial
Get a trial of GitLab Duo Pro to test the [GitLab Duo Pro features](../user/gitlab_duo/feature_summary.md)
for a limited time.
You can get a trial of GitLab Duo Pro if you have the Premium tier on GitLab.com, GitLab Self-Managed, or GitLab Dedicated.
### On GitLab.com
Prerequisites:
- You must have the Owner role for a top-level group that has an active paid Premium subscription. Indirect ownership through group membership is not sufficient.
To start a GitLab Duo Pro trial on GitLab.com:
1. On the left sidebar, select **Search or go to** and find your group.
1. Select **Settings > Billing**.
1. Select **Start a free GitLab Duo Pro trial**.
1. Complete the fields.
1. Select **Continue**.
1. If prompted, select the group that the trial should be applied to.
1. Select **Activate my trial**.
1. [Assign seats](subscription-add-ons.md#assign-gitlab-duo-seats) to the users who need access.
### On GitLab Self-Managed
Prerequisites:
- You must have an active paid Premium subscription.
- You must have GitLab 16.8 or later and your instance must be able to [synchronize your subscription data](manage_subscription.md#subscription-data-synchronization) with GitLab.
- GitLab Duo requires GitLab 17.2 and later for the best user experience and results. Earlier versions might continue to work, however the experience may be degraded.
To start a GitLab Duo Pro trial on GitLab Self-Managed or GitLab Dedicated:
1. Go to the [GitLab Duo Pro trial page](https://about.gitlab.com/solutions/gitlab-duo-pro/sales/?toggle=gitlab-duo-pro).
1. Complete the fields.
- To find your subscription name:
1. In the Customers Portal, on the **Subscriptions & purchases** page, find the subscription you want to apply the trial to.
1. At the top of the page, the subscription name appears in a badge.
- Ensure the email address you submit for trial registration matches the email address of the [subscription contact](customers_portal.md#change-your-subscription-contact).
1. Select **Submit**.
The trial automatically synchronizes to your instance within 24 hours. After the trial has synchronized, [assign seats](subscription-add-ons.md#assign-gitlab-duo-seats) to users that you want to access GitLab Duo.
### On GitLab Dedicated
Reach out to your Sales contact if you are interested in a trial.
## Start GitLab Duo Enterprise trial
Get a trial of GitLab Duo Enterprise to test the [GitLab Duo Enterprise features](../user/gitlab_duo/feature_summary.md)
for a limited time.
You can get a trial of GitLab Duo Enterprise if:
- You have the Free tier on GitLab.com. In that case, you can try Ultimate tier with GitLab Duo Enterprise.
- You have the Premium or Ultimate tier on GitLab.com, GitLab Self-Managed, or GitLab Dedicated.
If you have the Free tier on GitLab Self-Managed, no trial is available.
### On GitLab.com
Prerequisites:
- You must have the Owner role for a top-level group that has an active paid Ultimate subscription.
To start a GitLab Duo Enterprise trial on GitLab.com:
1. On the left sidebar, select **Search or go to** and find your group.
1. Select **Settings > Billing**.
1. Select **Start a free GitLab Duo Enterprise trial**.
1. Complete the fields.
1. Select **Continue**.
1. If prompted, select the group that the trial should be applied to.
1. Select **Activate my trial**.
1. [Assign seats](subscription-add-ons.md#assign-gitlab-duo-seats) to the users who need access.
### On GitLab Self-Managed
Prerequisites:
- You must have an active paid Ultimate subscription.
- You must have GitLab 17.3 or later and your instance must be able to [synchronize your subscription data](manage_subscription.md#subscription-data-synchronization) with GitLab.
To start a GitLab Duo Enterprise trial on GitLab Self-Managed or GitLab Dedicated:
1. Go to the [GitLab Duo Enterprise trial page](https://about.gitlab.com/solutions/gitlab-duo-pro/sales/?toggle=gitlab-duo-enterprise).
1. Complete the fields.
- To find your subscription name:
1. In the Customers Portal, on the **Subscriptions & purchases** page, find the subscription you want to apply the trial to.
1. At the top of the page, the subscription name appears in a badge.
- Ensure the email address you submit for trial registration matches the email address of the [subscription contact](customers_portal.md#change-your-subscription-contact).
1. Select **Submit**.
The trial automatically synchronizes to your instance within 24 hours. After the trial has synchronized, [assign seats](subscription-add-ons.md#assign-gitlab-duo-seats) to users that you want to access GitLab Duo.
### On GitLab Dedicated
Reach out to your Sales contact if you are interested in a trial.
|
https://docs.gitlab.com/quarterly_reconciliation
|
https://gitlab.com/gitlab-org/gitlab/-/tree/master/doc/quarterly_reconciliation.md
|
2025-08-13
|
doc/subscriptions
|
[
"doc",
"subscriptions"
] |
quarterly_reconciliation.md
|
Fulfillment
|
Subscription Management
|
To determine the technical writer assigned to the Stage/Group associated with this page, see https://handbook.gitlab.com/handbook/product/ux/technical-writing/#assignments
|
Quarterly reconciliation and annual true-ups
|
Billing examples.
|
{{< details >}}
- Tier: Premium, Ultimate
- Offering: GitLab.com, GitLab Self-Managed, GitLab Dedicated
{{< /details >}}
In accordance with [the GitLab Subscription Agreement](https://about.gitlab.com/terms/),
GitLab reviews your seat usage and sends you an invoice for any overages.
This review occurs either quarterly (quarterly reconciliation process) or annually (annual true-up process).
To learn more about how GitLab bills GitLab.com users, see [How seat usage is determined](manage_users_and_seats.md#gitlabcom-billing-and-usage). For GitLab Self-Managed users, see [How GitLab bills for users](manage_users_and_seats.md#self-managed-billing-and-usage).
To prevent overages, you can turn on restricted access for [your group](../user/group/manage.md#turn-on-restricted-access)
or [your instance](../administration/settings/sign_up_restrictions.md#turn-on-restricted-access).
This setting restricts groups from adding new billable users when there are no seats left in the subscription.
## Quarterly reconciliation versus annual true-ups
With **quarterly reconciliation**, you are billed per quarter on a prorated basis for the remaining portion of the subscription term.
You pay for the maximum number of seats you used during the quarter.
You pay less annually, which can result in substantial savings.
With **annual true-up**, you pay the full annual subscription fee for users added at any time during the year.
If you cannot participate in quarterly reconciliation, you can opt out of the process by using a contract amendment,
and default to the annual review.
### Example
For example, in January you purchased an annual license for 100 users, where each extra seat costs $100.
Throughout the year, the number of users fluctuated between 95 and 120.
The following chart illustrates the number of users during the year, per month and quarter.
If you are billed annually:
- During the year, you went over the license by 20 users.
- For the extra seats, you pay $100 x 20 users.
- The annual total cost is $2000.
If you are billed quarterly:
- In Q1 you had 110 users. 10 users over subscription x $25 per user x 3 quarters = $750.
You now pay a license for 110 users.
- In Q2 you had 105 users. You did not go over 110 users, so you are not charged.
- In Q3 you had 120 users. 10 users over subscription x $25 per user x 1 remaining quarter = $250.
You now pay a license for 120 users.
- In Q4 you had 120 users. You did not exceed the number of users from Q3, so you are not charged.
However, even if you exceeded the number you would not be charged, because in Q4 there are no charges for exceeding the number.
- The annual total cost is $1000.
## Quarterly invoicing and payment
At the end of each subscription quarter, GitLab notifies you about overages.
The date you're notified about the overage is not the same as the date you are billed.
1. An email that communicates the [overage seat quantity](manage_users_and_seats.md#seats-owed)
and expected invoice amount is sent:
- On GitLab.com: On the reconciliation date, to group owners.
- On GitLab Self-Managed: Six days after the reconciliation date, to administrators.
1. Seven days after the email notification, the subscription is updated to include the additional seats,
and an invoice is generated for a prorated amount.
If a credit card is on file, the payment applies automatically.
Otherwise, you receive an invoice, which is subject to your payment terms.
## Quarterly reconciliation eligibility
You are automatically enrolled in quarterly reconciliation if:
- The credit card you used to purchase your subscription is still linked to your GitLab account.
- You purchased your subscription through an invoice.
You are excluded from quarterly reconciliation if you:
- Purchased your subscription from a reseller or another channel partner.
- Purchased a subscription that is not a 12-month term (includes multi-year and non-standard length subscriptions).
- Purchased your subscription with a purchasing order.
- Purchased an [Enterprise Agile Planning](manage_subscription.md#enterprise-agile-planning) product.
- Are a public sector customer.
- Have an offline environment and used a license file to activate your subscription.
- Are enrolled in a program that provides a Free tier such as the GitLab for Education,
GitLab for Open Source Program, or GitLab for Startups.
If you are excluded from quarterly reconciliation and not on a Free tier, your true-ups are reconciled annually.
Alternatively, you can reconcile any overages by [purchasing additional seats](manage_users_and_seats.md#buy-more-seats).
## Troubleshooting
### Failed payment
If your credit card is declined during the reconciliation process, you receive an email with the subject `Action required: Your GitLab subscription failed to reconcile`. To resolve this issue, you must:
1. [Update your payment information](customers_portal.md#change-your-payment-method).
1. [Set your chosen payment method as default](customers_portal.md#set-a-default-payment-method).
When the payment method is updated, reconciliation is retried automatically.
|
---
stage: Fulfillment
group: Subscription Management
info: To determine the technical writer assigned to the Stage/Group associated with
this page, see https://handbook.gitlab.com/handbook/product/ux/technical-writing/#assignments
description: Billing examples.
title: Quarterly reconciliation and annual true-ups
breadcrumbs:
- doc
- subscriptions
---
{{< details >}}
- Tier: Premium, Ultimate
- Offering: GitLab.com, GitLab Self-Managed, GitLab Dedicated
{{< /details >}}
In accordance with [the GitLab Subscription Agreement](https://about.gitlab.com/terms/),
GitLab reviews your seat usage and sends you an invoice for any overages.
This review occurs either quarterly (quarterly reconciliation process) or annually (annual true-up process).
To learn more about how GitLab bills GitLab.com users, see [How seat usage is determined](manage_users_and_seats.md#gitlabcom-billing-and-usage). For GitLab Self-Managed users, see [How GitLab bills for users](manage_users_and_seats.md#self-managed-billing-and-usage).
To prevent overages, you can turn on restricted access for [your group](../user/group/manage.md#turn-on-restricted-access)
or [your instance](../administration/settings/sign_up_restrictions.md#turn-on-restricted-access).
This setting restricts groups from adding new billable users when there are no seats left in the subscription.
## Quarterly reconciliation versus annual true-ups
With **quarterly reconciliation**, you are billed per quarter on a prorated basis for the remaining portion of the subscription term.
You pay for the maximum number of seats you used during the quarter.
You pay less annually, which can result in substantial savings.
With **annual true-up**, you pay the full annual subscription fee for users added at any time during the year.
If you cannot participate in quarterly reconciliation, you can opt out of the process by using a contract amendment,
and default to the annual review.
### Example
For example, in January you purchased an annual license for 100 users, where each extra seat costs $100.
Throughout the year, the number of users fluctuated between 95 and 120.
The following chart illustrates the number of users during the year, per month and quarter.
If you are billed annually:
- During the year, you went over the license by 20 users.
- For the extra seats, you pay $100 x 20 users.
- The annual total cost is $2000.
If you are billed quarterly:
- In Q1 you had 110 users. 10 users over subscription x $25 per user x 3 quarters = $750.
You now pay a license for 110 users.
- In Q2 you had 105 users. You did not go over 110 users, so you are not charged.
- In Q3 you had 120 users. 10 users over subscription x $25 per user x 1 remaining quarter = $250.
You now pay a license for 120 users.
- In Q4 you had 120 users. You did not exceed the number of users from Q3, so you are not charged.
However, even if you exceeded the number you would not be charged, because in Q4 there are no charges for exceeding the number.
- The annual total cost is $1000.
## Quarterly invoicing and payment
At the end of each subscription quarter, GitLab notifies you about overages.
The date you're notified about the overage is not the same as the date you are billed.
1. An email that communicates the [overage seat quantity](manage_users_and_seats.md#seats-owed)
and expected invoice amount is sent:
- On GitLab.com: On the reconciliation date, to group owners.
- On GitLab Self-Managed: Six days after the reconciliation date, to administrators.
1. Seven days after the email notification, the subscription is updated to include the additional seats,
and an invoice is generated for a prorated amount.
If a credit card is on file, the payment applies automatically.
Otherwise, you receive an invoice, which is subject to your payment terms.
## Quarterly reconciliation eligibility
You are automatically enrolled in quarterly reconciliation if:
- The credit card you used to purchase your subscription is still linked to your GitLab account.
- You purchased your subscription through an invoice.
You are excluded from quarterly reconciliation if you:
- Purchased your subscription from a reseller or another channel partner.
- Purchased a subscription that is not a 12-month term (includes multi-year and non-standard length subscriptions).
- Purchased your subscription with a purchasing order.
- Purchased an [Enterprise Agile Planning](manage_subscription.md#enterprise-agile-planning) product.
- Are a public sector customer.
- Have an offline environment and used a license file to activate your subscription.
- Are enrolled in a program that provides a Free tier such as the GitLab for Education,
GitLab for Open Source Program, or GitLab for Startups.
If you are excluded from quarterly reconciliation and not on a Free tier, your true-ups are reconciled annually.
Alternatively, you can reconcile any overages by [purchasing additional seats](manage_users_and_seats.md#buy-more-seats).
## Troubleshooting
### Failed payment
If your credit card is declined during the reconciliation process, you receive an email with the subject `Action required: Your GitLab subscription failed to reconcile`. To resolve this issue, you must:
1. [Update your payment information](customers_portal.md#change-your-payment-method).
1. [Set your chosen payment method as default](customers_portal.md#set-a-default-payment-method).
When the payment method is updated, reconciliation is retried automatically.
|
https://docs.gitlab.com/subscriptions
|
https://gitlab.com/gitlab-org/gitlab/-/tree/master/doc/_index.md
|
2025-08-13
|
doc/subscriptions
|
[
"doc",
"subscriptions"
] |
_index.md
|
Fulfillment
|
Subscription Management
|
To determine the technical writer assigned to the Stage/Group associated with this page, see https://handbook.gitlab.com/handbook/product/ux/technical-writing/#assignments
|
Subscribe to GitLab
|
Choose and manage the subscription that's right for you and your organization.
|
Choose and manage the subscription that's right for you and your organization.
{{< cards >}}
- [GitLab plans](choosing_subscription.md)
- [Manage subscription](manage_subscription.md)
- [Manage users and seats](manage_users_and_seats.md)
- [GitLab.com subscription](gitlab_com/_index.md)
- [GitLab Self-Managed subscription](self_managed/_index.md)
- [GitLab Dedicated](gitlab_dedicated/_index.md)
- [GitLab Duo add-ons](subscription-add-ons.md)
- [Community programs](community_programs.md)
- [The Customers Portal](customers_portal.md)
- [Quarterly reconciliation and annual true-ups](quarterly_reconciliation.md)
{{< /cards >}}
|
---
stage: Fulfillment
group: Subscription Management
info: To determine the technical writer assigned to the Stage/Group associated with
this page, see https://handbook.gitlab.com/handbook/product/ux/technical-writing/#assignments
title: Subscribe to GitLab
description: Choose and manage the subscription that's right for you and your organization.
breadcrumbs:
- doc
- subscriptions
---
Choose and manage the subscription that's right for you and your organization.
{{< cards >}}
- [GitLab plans](choosing_subscription.md)
- [Manage subscription](manage_subscription.md)
- [Manage users and seats](manage_users_and_seats.md)
- [GitLab.com subscription](gitlab_com/_index.md)
- [GitLab Self-Managed subscription](self_managed/_index.md)
- [GitLab Dedicated](gitlab_dedicated/_index.md)
- [GitLab Duo add-ons](subscription-add-ons.md)
- [Community programs](community_programs.md)
- [The Customers Portal](customers_portal.md)
- [Quarterly reconciliation and annual true-ups](quarterly_reconciliation.md)
{{< /cards >}}
|
https://docs.gitlab.com/subscription-add-ons
|
https://gitlab.com/gitlab-org/gitlab/-/tree/master/doc/subscription-add-ons.md
|
2025-08-13
|
doc/subscriptions
|
[
"doc",
"subscriptions"
] |
subscription-add-ons.md
|
Fulfillment
|
Seat Management
|
To determine the technical writer assigned to the Stage/Group associated with this page, see https://handbook.gitlab.com/handbook/product/ux/technical-writing/#assignments
|
GitLab Duo add-ons
|
Seat assignment, GitLab Duo subscription add-on.
|
{{< details >}}
- Tier: Premium, Ultimate
- Offering: GitLab.com, GitLab Self-Managed, GitLab Dedicated
{{< /details >}}
{{< history >}}
- Changed to include GitLab Duo Core add-on in GitLab 18.0.
{{< /history >}}
GitLab Duo add-ons extend your Premium or Ultimate subscription with AI-native features.
Use GitLab Duo to help accelerate development workflows, reduce repetitive coding tasks,
and gain deeper insights across your projects.
Three add-ons are available: GitLab Duo Core, Pro, and Enterprise.
Each add-on provides access to
[a set of GitLab Duo features](../user/gitlab_duo/feature_summary.md).
## GitLab Duo Core
GitLab Duo Core is included automatically if you have:
- GitLab 18.0 or later.
- A Premium or Ultimate subscription.
If you are a new customer in GitLab 18.0 or later, IDE features are automatically turned on and no further action is needed.
If you are a pre-existing customer from GitLab 17.11 or earlier, you must [turn on IDE features](../user/gitlab_duo/turn_on_off.md#turn-gitlab-duo-core-on-or-off) to start using GitLab Duo in your IDEs. No further action is needed.
Users assigned the following roles have access to GitLab Duo Core:
- Reporter
- Developer
- Maintainer
- Owner
### GitLab Duo Core limits
Usage limits, along with [the GitLab Terms of Service](https://about.gitlab.com/terms/),
apply to Premium and Ultimate customers' use of the included Code Suggestions and GitLab Duo Chat features.
GitLab will provide 30 days prior notice before enforcement of these limits take effect.
At that time, organization administrators will have tools to monitor and manage consumption and will be able
to purchase additional capacity.
| Feature | Requests per user per month |
|------------------|-----------------------------|
| Code Suggestions | 2,000 |
| GitLab Duo Chat | 100 |
Limits do not apply to GitLab Duo Pro or Enterprise.
## GitLab Duo Pro and Enterprise
GitLab Duo Pro and Enterprise require you to purchase seats and assign them to team members.
The seat-based model gives you control over feature access and cost management
based on your specific team needs.
## Purchase GitLab Duo
To purchase GitLab Duo Enterprise, contact the
[GitLab Sales team](https://about.gitlab.com/solutions/gitlab-duo-pro/sales/).
To purchase seats for GitLab Duo Pro, use the Customers Portal or
contact the [GitLab Sales team](https://about.gitlab.com/solutions/gitlab-duo-pro/sales/).
To use the portal:
1. Sign in to the [GitLab Customers Portal](https://customers.gitlab.com/).
1. On the subscription card, select the vertical ellipsis ({{< icon name="ellipsis_v" >}}).
1. Select **Buy GitLab Duo Pro**.
1. Enter the number of seats for GitLab Duo.
1. Review the **Purchase summary** section.
1. From the **Payment method** dropdown list, select your payment method.
1. Select **Purchase seats**.
## Purchase additional GitLab Duo seats
You can purchase additional GitLab Duo Pro or GitLab Duo Enterprise seats for your group namespace or GitLab Self-Managed instance. After you complete the purchase, the seats are added to the total number of GitLab Duo seats in your subscription.
Prerequisites:
- You must purchase the GitLab Duo Pro or GitLab Duo Enterprise add-on.
### For GitLab.com
Prerequisites:
- You must have the Owner role.
1. On the left sidebar, select **Search or go to** and find your group.
1. Select **Settings > GitLab Duo**.
1. By **Seat utilization**, select **Assign seats**.
1. Select **Purchase seats**.
1. In the Customers Portal, in the **Add additional seats** field, enter the number of seats. The amount
cannot be higher than the number of seats in the subscription associated with your group namespace.
1. In the **Billing information** section, select the payment method from the dropdown list.
1. Select the **Privacy Policy** and **Terms of Service** checkbox.
1. Select **Purchase seats**.
1. Select the **GitLab SaaS** tab and refresh the page.
### For GitLab Self-Managed and GitLab Dedicated
Prerequisites:
- You must be an administrator.
1. Sign in to the [GitLab Customers Portal](https://customers.gitlab.com/).
1. On the **GitLab Duo Pro** section of your subscription card select **Add seats**.
1. Enter the number of seats. The amount cannot be higher than the number of seats in the subscription.
1. Review the **Purchase summary** section.
1. From the **Payment method** dropdown list, select your payment method.
1. Select **Purchase seats**.
## Assign GitLab Duo seats
Prerequisites:
- You must purchase a GitLab Duo Pro or Enterprise add-on, or have an active GitLab Duo trial.
- For GitLab Self-Managed and GitLab Dedicated:
- The GitLab Duo Pro add-on is available in GitLab 16.8 and later.
- The GitLab Duo Enterprise add-on is only available in GitLab 17.3 and later.
After you purchase GitLab Duo Pro or Enterprise, you can assign seats to users to grant access to the add-on.
### For GitLab.com
Prerequisites:
- You must have the Owner role.
To use GitLab Duo features in any project or group, you must assign the user to a seat in at least one top-level group.
1. On the left sidebar, select **Search or go to** and find your group.
1. Select **Settings > GitLab Duo**.
1. By **Seat utilization**, select **Assign seats**.
1. To the right of the user, turn on the toggle to assign a GitLab Duo seat.
The user is sent a confirmation email.
### For GitLab Self-Managed
Prerequisites:
- You must be an administrator.
1. On the left sidebar, at the bottom, select **Admin**.
1. Select **GitLab Duo**.
- If the **GitLab Duo** menu item is not available, synchronize your subscription
after purchase:
1. On the left sidebar, select **Subscription**.
1. In **Subscription details**, to the right of **Last sync**, select
synchronize subscription ({{< icon name="retry" >}}).
1. By **Seat utilization**, select **Assign seats**.
1. To the right of the user, turn on the toggle to assign a GitLab Duo seat.
The user is sent a confirmation email.
After you assign seats,
[ensure GitLab Duo is set up for your GitLab Self-Managed instance](../user/gitlab_duo/setup.md).
## Assign and remove GitLab Duo seats in bulk
You can assign or remove seats in bulk for multiple users.
### SAML Group Sync
GitLab.com groups can use SAML Group Sync to [manage GitLab Duo seat assignments](../user/group/saml_sso/group_sync.md#manage-gitlab-duo-seat-assignment).
### For GitLab.com
1. On the left sidebar, select **Search or go to** and find your group.
1. Select **Settings > GitLab Duo**.
1. On the bottom right, you can adjust the page display to show **50** or **100** items to increase the number of users available for selection.
1. Select the users to assign or remove seats for:
- To select multiple users, to the left of each user, select the checkbox.
- To select all, select the checkbox at the top of the table.
1. Assign or remove seats:
- To assign seats, select **Assign seat**, then **Assign seats** to confirm.
- To remove users from seats, select **Remove seat**, then **Remove seats** to confirm.
### For GitLab Self-Managed
Prerequisites:
- You must be an administrator.
- You must have GitLab 17.5 or later.
1. On the left sidebar, at the bottom, select **Admin**.
1. Select **GitLab Duo**.
1. On the bottom right, you can adjust the page display to show **50** or **100** items to increase the number of users available for selection.
1. Select the users to assign or remove seats for:
- To select multiple users, to the left of each user, select the checkbox.
- To select all, select the checkbox at the top of the table.
1. Assign or remove seats:
- To assign seats, select **Assign seat**, then **Assign seats** to confirm.
- To remove users from seats, select **Remove seat**, then **Remove seats** to confirm.
1. To the right of the user, turn on the toggle to assign a GitLab Duo seat.
Administrators of GitLab Self-Managed instances can also use a [Rake task](../administration/raketasks/user_management.md#bulk-assign-users-to-gitlab-duo) to assign or remove seats in bulk.
#### Managing GitLab Duo seats with LDAP configuration
You can automatically assign and remove GitLab Duo seats for LDAP-enabled users based on LDAP group membership.
To enable this functionality, you must [configure the `duo_add_on_groups` property](../administration/auth/ldap/ldap_synchronization.md#gitlab-duo-add-on-for-groups) in your LDAP settings.
When `duo_add_on_groups` is configured, it becomes the single source of truth for Duo seat management among LDAP-enabled users.
For more information, see [seat assignment workflow](../administration/duo_add_on_seat_management_with_ldap.md#seat-management-workflow).
This automated process ensures that Duo seats are efficiently allocated based on your organization's LDAP group structure.
For more information, see [GitLab Duo add-on seat management with LDAP](../administration/duo_add_on_seat_management_with_ldap.md).
## View assigned GitLab Duo users
{{< history >}}
- Last GitLab Duo activity field [introduced](https://gitlab.com/gitlab-org/gitlab/-/issues/455761) in GitLab 18.0.
{{< /history >}}
Prerequisites:
- You must purchase a GitLab Duo Pro or Enterprise add-on, or have an active GitLab Duo trial.
After you purchase GitLab Duo Pro or Enterprise, you can assign seats to users to
grant access to the add-on. Then you can view details of assigned GitLab Duo users.
The GitLab Duo seat utilization page shows the following information for each user:
- User's full name and username
- Seat assignment status
- Public email address: The user's email displayed on their public profile.
- Last GitLab activity: The date the user last performed any action in GitLab.
- Last GitLab Duo activity: The date the user last used GitLab Duo features. Refreshes on any GitLab Duo activity.
These fields use data from the `AddOnUser` type in the [GraphQL API](../api/graphql/reference/_index.md#addonuser).
### For GitLab.com
Prerequisites:
- You must have the Owner role.
1. On the left sidebar, select **Search or go to** and find your group.
1. Select **Settings > GitLab Duo**.
1. By **Seat utilization**, select **Assign seats**.
1. From the filter bar, select **Assigned seat** and **Yes**.
1. User list is filtered to only users assigned a GitLab Duo seat.
### For GitLab Self-Managed
Prerequisites:
- You must be an administrator.
- You must have GitLab 17.5 or later.
1. On the left sidebar, at the bottom, select **Admin**.
1. Select **GitLab Duo**.
- If the **GitLab Duo** menu item is not available, synchronize your subscription
after purchase:
1. On the left sidebar, select **Subscription**.
1. In **Subscription details**, to the right of **Last sync**, select
synchronize subscription ({{< icon name="retry" >}}).
1. By **Seat utilization**, select **Assign seats**.
1. To filter by users assigned to a GitLab Duo seat, in the **Filter users** bar, select **Assigned seat**, then select **Yes**.
1. User list is filtered to only users assigned a GitLab Duo seat.
## Automatic seat removal
GitLab Duo add-on seats are removed automatically to ensure only eligible users have access. This
happens when there are:
- Seat overages
- Blocked, banned, and deactivated users
### At subscription expiration
If your subscription containing the GitLab Duo add-on expires, seat assignments are retained for 28 days. If the subscription is renewed, or a new subscription containing GitLab Duo is purchased during this 28-day window, users will be automatically re-assigned.
At the end of the 28 day grace period, seat assignments are removed and users will need to be reassigned.
### For seat overages
If your quantity of purchased GitLab Duo add-on seats is reduced, seat assignments are automatically removed to match the seat quantity available in the subscription.
For example:
- You have a 50 seat GitLab Duo Pro subscription with all seats assigned.
- You renew the subscription for 30 seats. The 20 users over subscription are automatically removed from GitLab Duo Pro seat assignment.
- If only 20 users were assigned a GitLab Duo Pro seat before renewal, then no removal of seats would occur.
Seats are selected for removal based on the following criteria, in this order:
1. Users who have not yet used Code Suggestions, ordered by most recently assigned.
1. Users who have used Code Suggestions, ordered by least recent usage of Code Suggestions.
### For blocked, banned and deactivated users
Once or twice each day, a CronJob reviews GitLab Duo seat assignments. If a user who is assigned a GitLab Duo seat becomes
blocked, banned, or deactivated, their access to GitLab Duo features is automatically removed.
After the seat has been removed, it becomes available and can be re-assigned to a new user.
## Troubleshooting
### Unable to use the UI to assign seats to your users
On the **Usage quotas** page, if you experience both of the following, you will be unable to use the UI to assign seats to your users:
- The **Seats** tab does not load.
- The following error message is displayed:
```plaintext
An error occurred while loading billable members list.
```
As a workaround, you can use the GraphQL queries in [this snippet](https://gitlab.com/gitlab-org/gitlab/-/snippets/3763094) to assign seats to users.
|
---
stage: Fulfillment
group: Seat Management
info: To determine the technical writer assigned to the Stage/Group associated with
this page, see https://handbook.gitlab.com/handbook/product/ux/technical-writing/#assignments
description: Seat assignment, GitLab Duo subscription add-on.
title: GitLab Duo add-ons
breadcrumbs:
- doc
- subscriptions
---
{{< details >}}
- Tier: Premium, Ultimate
- Offering: GitLab.com, GitLab Self-Managed, GitLab Dedicated
{{< /details >}}
{{< history >}}
- Changed to include GitLab Duo Core add-on in GitLab 18.0.
{{< /history >}}
GitLab Duo add-ons extend your Premium or Ultimate subscription with AI-native features.
Use GitLab Duo to help accelerate development workflows, reduce repetitive coding tasks,
and gain deeper insights across your projects.
Three add-ons are available: GitLab Duo Core, Pro, and Enterprise.
Each add-on provides access to
[a set of GitLab Duo features](../user/gitlab_duo/feature_summary.md).
## GitLab Duo Core
GitLab Duo Core is included automatically if you have:
- GitLab 18.0 or later.
- A Premium or Ultimate subscription.
If you are a new customer in GitLab 18.0 or later, IDE features are automatically turned on and no further action is needed.
If you are a pre-existing customer from GitLab 17.11 or earlier, you must [turn on IDE features](../user/gitlab_duo/turn_on_off.md#turn-gitlab-duo-core-on-or-off) to start using GitLab Duo in your IDEs. No further action is needed.
Users assigned the following roles have access to GitLab Duo Core:
- Reporter
- Developer
- Maintainer
- Owner
### GitLab Duo Core limits
Usage limits, along with [the GitLab Terms of Service](https://about.gitlab.com/terms/),
apply to Premium and Ultimate customers' use of the included Code Suggestions and GitLab Duo Chat features.
GitLab will provide 30 days prior notice before enforcement of these limits take effect.
At that time, organization administrators will have tools to monitor and manage consumption and will be able
to purchase additional capacity.
| Feature | Requests per user per month |
|------------------|-----------------------------|
| Code Suggestions | 2,000 |
| GitLab Duo Chat | 100 |
Limits do not apply to GitLab Duo Pro or Enterprise.
## GitLab Duo Pro and Enterprise
GitLab Duo Pro and Enterprise require you to purchase seats and assign them to team members.
The seat-based model gives you control over feature access and cost management
based on your specific team needs.
## Purchase GitLab Duo
To purchase GitLab Duo Enterprise, contact the
[GitLab Sales team](https://about.gitlab.com/solutions/gitlab-duo-pro/sales/).
To purchase seats for GitLab Duo Pro, use the Customers Portal or
contact the [GitLab Sales team](https://about.gitlab.com/solutions/gitlab-duo-pro/sales/).
To use the portal:
1. Sign in to the [GitLab Customers Portal](https://customers.gitlab.com/).
1. On the subscription card, select the vertical ellipsis ({{< icon name="ellipsis_v" >}}).
1. Select **Buy GitLab Duo Pro**.
1. Enter the number of seats for GitLab Duo.
1. Review the **Purchase summary** section.
1. From the **Payment method** dropdown list, select your payment method.
1. Select **Purchase seats**.
## Purchase additional GitLab Duo seats
You can purchase additional GitLab Duo Pro or GitLab Duo Enterprise seats for your group namespace or GitLab Self-Managed instance. After you complete the purchase, the seats are added to the total number of GitLab Duo seats in your subscription.
Prerequisites:
- You must purchase the GitLab Duo Pro or GitLab Duo Enterprise add-on.
### For GitLab.com
Prerequisites:
- You must have the Owner role.
1. On the left sidebar, select **Search or go to** and find your group.
1. Select **Settings > GitLab Duo**.
1. By **Seat utilization**, select **Assign seats**.
1. Select **Purchase seats**.
1. In the Customers Portal, in the **Add additional seats** field, enter the number of seats. The amount
cannot be higher than the number of seats in the subscription associated with your group namespace.
1. In the **Billing information** section, select the payment method from the dropdown list.
1. Select the **Privacy Policy** and **Terms of Service** checkbox.
1. Select **Purchase seats**.
1. Select the **GitLab SaaS** tab and refresh the page.
### For GitLab Self-Managed and GitLab Dedicated
Prerequisites:
- You must be an administrator.
1. Sign in to the [GitLab Customers Portal](https://customers.gitlab.com/).
1. On the **GitLab Duo Pro** section of your subscription card select **Add seats**.
1. Enter the number of seats. The amount cannot be higher than the number of seats in the subscription.
1. Review the **Purchase summary** section.
1. From the **Payment method** dropdown list, select your payment method.
1. Select **Purchase seats**.
## Assign GitLab Duo seats
Prerequisites:
- You must purchase a GitLab Duo Pro or Enterprise add-on, or have an active GitLab Duo trial.
- For GitLab Self-Managed and GitLab Dedicated:
- The GitLab Duo Pro add-on is available in GitLab 16.8 and later.
- The GitLab Duo Enterprise add-on is only available in GitLab 17.3 and later.
After you purchase GitLab Duo Pro or Enterprise, you can assign seats to users to grant access to the add-on.
### For GitLab.com
Prerequisites:
- You must have the Owner role.
To use GitLab Duo features in any project or group, you must assign the user to a seat in at least one top-level group.
1. On the left sidebar, select **Search or go to** and find your group.
1. Select **Settings > GitLab Duo**.
1. By **Seat utilization**, select **Assign seats**.
1. To the right of the user, turn on the toggle to assign a GitLab Duo seat.
The user is sent a confirmation email.
### For GitLab Self-Managed
Prerequisites:
- You must be an administrator.
1. On the left sidebar, at the bottom, select **Admin**.
1. Select **GitLab Duo**.
- If the **GitLab Duo** menu item is not available, synchronize your subscription
after purchase:
1. On the left sidebar, select **Subscription**.
1. In **Subscription details**, to the right of **Last sync**, select
synchronize subscription ({{< icon name="retry" >}}).
1. By **Seat utilization**, select **Assign seats**.
1. To the right of the user, turn on the toggle to assign a GitLab Duo seat.
The user is sent a confirmation email.
After you assign seats,
[ensure GitLab Duo is set up for your GitLab Self-Managed instance](../user/gitlab_duo/setup.md).
## Assign and remove GitLab Duo seats in bulk
You can assign or remove seats in bulk for multiple users.
### SAML Group Sync
GitLab.com groups can use SAML Group Sync to [manage GitLab Duo seat assignments](../user/group/saml_sso/group_sync.md#manage-gitlab-duo-seat-assignment).
### For GitLab.com
1. On the left sidebar, select **Search or go to** and find your group.
1. Select **Settings > GitLab Duo**.
1. On the bottom right, you can adjust the page display to show **50** or **100** items to increase the number of users available for selection.
1. Select the users to assign or remove seats for:
- To select multiple users, to the left of each user, select the checkbox.
- To select all, select the checkbox at the top of the table.
1. Assign or remove seats:
- To assign seats, select **Assign seat**, then **Assign seats** to confirm.
- To remove users from seats, select **Remove seat**, then **Remove seats** to confirm.
### For GitLab Self-Managed
Prerequisites:
- You must be an administrator.
- You must have GitLab 17.5 or later.
1. On the left sidebar, at the bottom, select **Admin**.
1. Select **GitLab Duo**.
1. On the bottom right, you can adjust the page display to show **50** or **100** items to increase the number of users available for selection.
1. Select the users to assign or remove seats for:
- To select multiple users, to the left of each user, select the checkbox.
- To select all, select the checkbox at the top of the table.
1. Assign or remove seats:
- To assign seats, select **Assign seat**, then **Assign seats** to confirm.
- To remove users from seats, select **Remove seat**, then **Remove seats** to confirm.
1. To the right of the user, turn on the toggle to assign a GitLab Duo seat.
Administrators of GitLab Self-Managed instances can also use a [Rake task](../administration/raketasks/user_management.md#bulk-assign-users-to-gitlab-duo) to assign or remove seats in bulk.
#### Managing GitLab Duo seats with LDAP configuration
You can automatically assign and remove GitLab Duo seats for LDAP-enabled users based on LDAP group membership.
To enable this functionality, you must [configure the `duo_add_on_groups` property](../administration/auth/ldap/ldap_synchronization.md#gitlab-duo-add-on-for-groups) in your LDAP settings.
When `duo_add_on_groups` is configured, it becomes the single source of truth for Duo seat management among LDAP-enabled users.
For more information, see [seat assignment workflow](../administration/duo_add_on_seat_management_with_ldap.md#seat-management-workflow).
This automated process ensures that Duo seats are efficiently allocated based on your organization's LDAP group structure.
For more information, see [GitLab Duo add-on seat management with LDAP](../administration/duo_add_on_seat_management_with_ldap.md).
## View assigned GitLab Duo users
{{< history >}}
- Last GitLab Duo activity field [introduced](https://gitlab.com/gitlab-org/gitlab/-/issues/455761) in GitLab 18.0.
{{< /history >}}
Prerequisites:
- You must purchase a GitLab Duo Pro or Enterprise add-on, or have an active GitLab Duo trial.
After you purchase GitLab Duo Pro or Enterprise, you can assign seats to users to
grant access to the add-on. Then you can view details of assigned GitLab Duo users.
The GitLab Duo seat utilization page shows the following information for each user:
- User's full name and username
- Seat assignment status
- Public email address: The user's email displayed on their public profile.
- Last GitLab activity: The date the user last performed any action in GitLab.
- Last GitLab Duo activity: The date the user last used GitLab Duo features. Refreshes on any GitLab Duo activity.
These fields use data from the `AddOnUser` type in the [GraphQL API](../api/graphql/reference/_index.md#addonuser).
### For GitLab.com
Prerequisites:
- You must have the Owner role.
1. On the left sidebar, select **Search or go to** and find your group.
1. Select **Settings > GitLab Duo**.
1. By **Seat utilization**, select **Assign seats**.
1. From the filter bar, select **Assigned seat** and **Yes**.
1. User list is filtered to only users assigned a GitLab Duo seat.
### For GitLab Self-Managed
Prerequisites:
- You must be an administrator.
- You must have GitLab 17.5 or later.
1. On the left sidebar, at the bottom, select **Admin**.
1. Select **GitLab Duo**.
- If the **GitLab Duo** menu item is not available, synchronize your subscription
after purchase:
1. On the left sidebar, select **Subscription**.
1. In **Subscription details**, to the right of **Last sync**, select
synchronize subscription ({{< icon name="retry" >}}).
1. By **Seat utilization**, select **Assign seats**.
1. To filter by users assigned to a GitLab Duo seat, in the **Filter users** bar, select **Assigned seat**, then select **Yes**.
1. User list is filtered to only users assigned a GitLab Duo seat.
## Automatic seat removal
GitLab Duo add-on seats are removed automatically to ensure only eligible users have access. This
happens when there are:
- Seat overages
- Blocked, banned, and deactivated users
### At subscription expiration
If your subscription containing the GitLab Duo add-on expires, seat assignments are retained for 28 days. If the subscription is renewed, or a new subscription containing GitLab Duo is purchased during this 28-day window, users will be automatically re-assigned.
At the end of the 28 day grace period, seat assignments are removed and users will need to be reassigned.
### For seat overages
If your quantity of purchased GitLab Duo add-on seats is reduced, seat assignments are automatically removed to match the seat quantity available in the subscription.
For example:
- You have a 50 seat GitLab Duo Pro subscription with all seats assigned.
- You renew the subscription for 30 seats. The 20 users over subscription are automatically removed from GitLab Duo Pro seat assignment.
- If only 20 users were assigned a GitLab Duo Pro seat before renewal, then no removal of seats would occur.
Seats are selected for removal based on the following criteria, in this order:
1. Users who have not yet used Code Suggestions, ordered by most recently assigned.
1. Users who have used Code Suggestions, ordered by least recent usage of Code Suggestions.
### For blocked, banned and deactivated users
Once or twice each day, a CronJob reviews GitLab Duo seat assignments. If a user who is assigned a GitLab Duo seat becomes
blocked, banned, or deactivated, their access to GitLab Duo features is automatically removed.
After the seat has been removed, it becomes available and can be re-assigned to a new user.
## Troubleshooting
### Unable to use the UI to assign seats to your users
On the **Usage quotas** page, if you experience both of the following, you will be unable to use the UI to assign seats to your users:
- The **Seats** tab does not load.
- The following error message is displayed:
```plaintext
An error occurred while loading billable members list.
```
As a workaround, you can use the GraphQL queries in [this snippet](https://gitlab.com/gitlab-org/gitlab/-/snippets/3763094) to assign seats to users.
|
https://docs.gitlab.com/manage_subscription
|
https://gitlab.com/gitlab-org/gitlab/-/tree/master/doc/manage_subscription.md
|
2025-08-13
|
doc/subscriptions
|
[
"doc",
"subscriptions"
] |
manage_subscription.md
|
Fulfillment
|
Subscription Management
|
To determine the technical writer assigned to the Stage/Group associated with this page, see https://handbook.gitlab.com/handbook/product/ux/technical-writing/#assignments
|
Manage subscription
|
Buy, view, and renew your GitLab subscriptions.
|
## Buy a subscription
You can buy a subscription for GitLab.com or GitLab Self-Managed.
The subscription determines which features are available for your private projects.
After you subscribe to GitLab, you can manage the details of your subscription.
If you experience any issues, see the [troubleshooting GitLab subscription](gitlab_com/gitlab_subscription_troubleshooting.md).
Organizations with public open source projects can apply to the [GitLab for Open Source program](community_programs.md#gitlab-for-open-source).
### For GitLab.com
{{< details >}}
- Tier: Premium, Ultimate
- Offering: GitLab.com
{{< /details >}}
GitLab.com is the GitLab multi-tenant software-as-a-service (SaaS) offering.
You don't need to install anything to use GitLab.com, you only need to [sign up](https://gitlab.com/users/sign_up).
When you sign up, you choose:
- [A subscription](https://about.gitlab.com/pricing/).
- The number of seats you want.
A GitLab.com subscription applies to a top-level group.
Members of every subgroup and project in the group:
- Can use the features of the subscription.
- Consume seats in the subscription.
To subscribe to GitLab.com:
1. View the [GitLab.com feature comparison](https://about.gitlab.com/pricing/feature-comparison/)
and decide which tier you want.
1. Create a user account for yourself by using the
[sign up page](https://gitlab.com/users/sign_up).
1. Create a [group](../user/group/_index.md#create-a-group). Your subscription tier applies to the top-level group, its subgroups, and projects.
1. Create additional users and
[add them to the group](../user/group/_index.md#add-users-to-a-group). The users in this group, its subgroups, and projects can use
the features of your subscription tier, and they consume a seat in your subscription.
1. On the left sidebar, select **Settings > Billing** and choose a tier. You are taken to the Customers Portal.
1. Fill out the form to complete your purchase.
### For GitLab Self-Managed
{{< details >}}
- Tier: Premium, Ultimate
- Offering: GitLab Self-Managed
{{< /details >}}
To subscribe to GitLab for a GitLab Self-Managed instance:
1. Go to the [Pricing page](https://about.gitlab.com/pricing/) and select a self-managed plan. You are redirected to the [Customers Portal](https://customers.gitlab.com/) to complete your purchase.
1. After purchase, an activation code is sent to the email address associated with the Customers Portal account.
You must [add this code to your GitLab instance](../administration/license.md).
{{< alert type="note" >}}
If you're purchasing a subscription for an existing **Free** GitLab Self-Managed
instance, ensure you're purchasing enough seats to
[cover your users](../administration/admin_area.md#administering-users).
{{< /alert >}}
## View subscription
### For GitLab.com
{{< details >}}
- Tier: Premium, Ultimate
- Offering: GitLab.com
{{< /details >}}
Prerequisites:
- You must have the Owner role for the group.
To see the status of your GitLab.com subscription:
1. On the left sidebar, select **Search or go to** and find your group.
1. Select **Settings > Billing**.
The following information is displayed:
| Field | Description |
|:----------------------------|:------------|
| **Seats in subscription** | If this is a paid plan, represents the number of seats you've bought for this group. |
| **Seats currently in use** | Number of seats in use. Select **See usage** to see a list of the users using these seats. |
| **Maximum seats used** | Highest number of seats you've used. |
| **Seats owed** | **Max seats used** minus **Seats in subscription**. |
| **Subscription start date** | Date your subscription started. |
| **Subscription end date** | Date your current subscription ends. |
### For GitLab Self-Managed
{{< details >}}
- Tier: Premium, Ultimate
- Offering: GitLab Self-Managed
{{< /details >}}
Prerequisites:
- You must be an administrator.
You can view the status of your subscription:
1. On the left sidebar, at the bottom, select **Admin**.
1. Select **Subscription**.
The **Subscription** page includes the following information:
- Licensee
- Plan
- When it was uploaded, started, and when it expires
- Number of users in subscription
- Number of billable users
- Maximum users
- Number of users over subscription
## Review your account
You should regularly review your billing account settings and purchasing information.
To review your billing account settings:
1. Sign in to the [Customers Portal](https://customers.gitlab.com/customers/sign_in).
1. Select **Billing account settings**.
1. Verify or update:
- Under **Payment methods**, the credit card on file.
- Under **Company information**, the subscription and billing contact details.
1. Save any changes.
You should also regularly review your user accounts to make sure that you are only
renewing for the correct number of active billable users. Inactive user accounts:
- Might count as billable users. You pay more than
you should if you renew inactive user accounts.
- Can be a security risk. A regular review helps reduce this risk.
For more information, see the documentation on:
- [User statistics](../administration/admin_area.md#users-statistics).
- [Managing users and subscription seats](manage_users_and_seats.md#manage-users-and-subscription-seats).
## Upgrade subscription tier
{{< details >}}
- Tier: Premium, Ultimate
- Offering: GitLab.com, GitLab Self-Managed
{{< /details >}}
To upgrade your [GitLab tier](https://about.gitlab.com/pricing/):
1. Sign in to the [Customers Portal](https://customers.gitlab.com/customers/sign_in).
1. Select **Upgrade plan** on the relevant subscription card.
1. Confirm the active form of payment, or add a new form of payment.
1. Select the **I accept the Privacy Statement and Terms of Service** checkbox.
1. Select **Upgrade subscription**.
The following is emailed to you:
- A payment receipt. You can also access this information in the Customers Portal under
[**Invoices**](https://customers.gitlab.com/invoices).
- On GitLab Self-Managed, a new activation code for your license.
On GitLab Self-Managed, the new tier takes effect on the next subscription sync.
You can also [synchronize your subscription manually](#subscription-data-synchronization)
to upgrade right away.
## Renew subscription
{{< details >}}
- Tier: Premium, Ultimate
- Offering: GitLab.com, GitLab Self-Managed
{{< /details >}}
Before your subscription renewal date, you should review your account to check
your current seat usage and billable users.
You can renew your subscription automatically or manually.
You should renew your subscription manually if you want to either:
- Renew for fewer seats.
- Increase or decrease the quantities of products being renewed.
- Remove add-on products no longer needed for the renewed subscription term.
- Upgrade the subscription tier.
The renewal period start date is displayed on the group Billing page under **Next subscription term start date**.
Contact the:
- [Support team](https://support.gitlab.com/hc/en-us/requests/new?ticket_form_id=360000071293)
if you need help accessing the Customers Portal or changing the contact person who manages your subscription.
- [Sales team](https://customers.gitlab.com/contact_us) if you need help renewing your subscription.
### Check when subscription expires
15 days before a subscription expires, a banner with the subscription expiry date displays for
administrators in the GitLab user interface.
You cannot manually renew your subscription more than 15 days before the subscription
expires. To check when you can renew:
1. Sign in to the [Customers Portal](https://customers.gitlab.com/customers/sign_in).
1. Select **Subscription actions** ({{< icon name="ellipsis_v" >}}), then select **Renew subscription**
to view the date you can renew.
### Renew automatically
Prerequisites:
- For GitLab Self-Managed, you must [synchronize subscription data](#subscription-data-synchronization) and review your account at least two days before renewal to ensure your changes are synchronized.
When a subscription is set to auto-renew, it renews automatically at midnight UTC on the expiration date without a gap in available service.
You receive [email notifications](#renewal-notifications) before a subscription automatically renews.
Subscriptions purchased through the Customers Portal are set to auto-renew by default,
but you can [turn off automatic subscription renewal](#turn-on-or-turn-off-automatic-subscription-renewal).
The number of user seats is adjusted to fit the number of billable users in your
[group](manage_users_and_seats.md#view-seat-usage) or [instance](manage_users_and_seats.md#view-users)
at the time of renewal, if that number is higher than the current subscription quantity.
#### Turn on or turn off automatic subscription renewal
You can use the Customers Portal to turn on or turn off automatic subscription renewal:
1. Sign in to the [Customers Portal](https://customers.gitlab.com/customers/sign_in).
You are taken to the **Subscriptions & purchases** page.
1. Check the subscription card:
- If the card displays **Expires on DATE**, your subscription is not
set to automatically renew. To enable automatic renewal, in
**Subscription actions** ({{< icon name="ellipsis_v" >}}), select **Turn on auto-renew**.
- If the card displays **Auto-renews on DATE**, your subscription is set to
automatically renew. To disable automatic renewal:
1. In **Subscription actions** ({{< icon name="ellipsis_v" >}}), select **Cancel subscription**.
1. Select a reason for canceling.
1. Optional: In **Would you like to add anything?**, enter any relevant information.
1. Select **Cancel subscription**.
### Renew manually
To manually renew your subscription:
1. Determine the number of users you need in the next subscription period.
1. Sign in to the [Customers Portal](https://customers.gitlab.com/customers/sign_in).
1. Under your existing subscription, select **Renew**. This button does not display
until 15 days before the subscription expires.
1. If renewing Premium or Ultimate products, in the **Seats** text box, enter the
total number of user seats you need for the upcoming year.
{{< alert type="note" >}}
Make sure this number is equal to, or greater than
the number of [billable users](manage_users_and_seats.md#billable-users) in the system at the time of renewal.
{{< /alert >}}
1. Optional. For GitLab Self-Managed, if the maximum number of users in your instance exceeded the number
you were licensed for in the previous subscription term, the
[overage](quarterly_reconciliation.md) is due when you renew.
In the **Users over license** text box, enter the number of
[users over subscription](manage_users_and_seats.md#users-over-subscription) for the user overage incurred.
1. Optional. If renewing add-on products, review and update the desired quantity. You can also remove products.
1. Optional. If upgrading the subscription tier, select the desired option.
1. Review your renewal details and select **Renew subscription** to complete the
payment process.
1. For GitLab Self-Managed, on the [Subscriptions & purchases](https://customers.gitlab.com/subscriptions)
page on the relevant subscription card, select **Copy activation code** to get
a copy of the renewal term activation code, and [add the activation code](../administration/license.md) to your instance.
To add products to your subscription, [contact the sales team](https://customers.gitlab.com/contact_us).
### Renew for fewer seats
Subscription renewals with fewer seats must have or exceed the current number of billable users.
Before you renew your subscription:
- For GitLab.com,
[reduce the number of billable users](manage_users_and_seats.md#remove-users-from-subscription)
if it exceeds the number of seats you want to renew for.
- For GitLab Self-Managed, [block inactive or unwanted users](../administration/moderate_users.md#block-a-user).
To manually renew your subscription for fewer seats, you can either:
- [Manually renew](#renew-manually) within 15 days of the
subscription renewal date. Ensure that you specify the seat quantity when you renew.
- [Turn off automatic renewal of your subscription](#turn-on-or-turn-off-automatic-subscription-renewal),
and contact the [sales team](https://customers.gitlab.com/contact_us) to renew it for the number of seats you want.
### Renewal notifications
15 days before a subscription automatically renews, an email is sent with information
about the renewal.
- If your credit card is expired, the email tells you how to update it.
- If you have any outstanding overages or your subscription is not able to automatically
renew for any other reason, the email tells you to contact our Sales team or
manually renew in the Customers Portal.
- If there are no issues, the email specifies the:
- Names and quantity of the products being renewed.
- Total amount you owe. If your usage increases before renewal, this amount changes.
### Manage renewal invoice
An invoice is generated for your renewal. To view or download this renewal invoice,
go to the [Customers Portal invoices page](https://customers.gitlab.com/invoices).
If your account has a [saved credit card](customers_portal.md#change-your-payment-method),
the card is charged for the invoice amount.
If we are unable to process a payment or the auto-renewal fails for any other reason,
you have 14 days to renew your subscription, after which your GitLab tier is downgraded.
## Expired subscription
Subscriptions expire at the start of the expiration date, 00:00 server time.
For example, if a subscription is valid from January 1, 2024 until January 1, 2025:
- It expires at 11:59:59 PM UTC December 31, 2024.
- It is considered expired from 12:00:00 AM UTC January 1, 2025.
- The grace period of 14 days starts at 12:00:00 AM UTC January 1, 2025 and ends at 11:59:59 PM UTC January 14, 2025.
### For GitLab.com
{{< details >}}
- Tier: Premium, Ultimate
- Offering: GitLab.com
{{< /details >}}
When your subscription expires, you can continue to use paid features of GitLab for 14 days.
After 14 days, paid features are no longer available, but you can continue to use free features.
To resume paid feature functionality, purchase a new subscription.
### For GitLab Self-Managed
{{< details >}}
- Tier: Premium, Ultimate
- Offering: GitLab Self-Managed
{{< /details >}}
When your license expires, after a 14 day grace period:
- Your instance becomes read-only.
- GitLab locks features, such as Git pushes and issue creation.
- An expiration message is displayed to all instance administrators.
After your license has expired:
- To resume functionality,
[activate a new subscription](../administration/license_file.md#activate-subscription-during-installation).
- To keep using Free tier features only,
[remove the expired license](../administration/license_file.md#remove-a-license).
## Subscription data synchronization
{{< details >}}
- Tier: Premium, Ultimate
- Offering: GitLab Self-Managed
{{< /details >}}
Prerequisites:
- GitLab Enterprise Edition (EE).
- Connection to the internet, and must not have an offline environment.
- [Activated](../administration/license.md) your instance with an activation code.
Your [subscription data](#subscription-data) is automatically synchronized once
a day between your GitLab Self-Managed instance and GitLab.
At approximately 3:00 AM (UTC), this daily synchronization job sends
[subscription data](#subscription-data) to the Customers Portal. For this reason,
updates and renewals might not apply immediately.
The data is sent securely through an encrypted HTTPS connection to
`customers.gitlab.com` on port `443`. If the job fails, it retries up to 12 times
over approximately 17 hours.
After you have set up automatic data synchronization, the following processes are
also automated.
- [Quarterly subscription reconciliation](quarterly_reconciliation.md).
- Subscription renewals.
- Subscription updates, such as adding more seats or upgrading a GitLab tier.
### Manually synchronize subscription data
You can also manually synchronize subscription data at any time.
1. On the left sidebar, at the bottom, select **Admin**.
1. Select **Subscription**.
1. In the **Subscription details** section, select **Sync** ({{< icon name="retry" >}}).
A synchronization job is then queued. When the job finishes, the subscription
details are updated.
### Subscription data
{{< history >}}
- Unique instance ID [introduced](https://gitlab.com/gitlab-org/gitlab/-/merge_requests/189399) in GitLab 18.1.
{{< /history >}}
The daily synchronization job sends the following information to the
Customers Portal:
- Date
- Timestamp
- License key, with the following encrypted within the key:
- Company name
- Licensee name
- Licensee email
- Historical [maximum user count](manage_users_and_seats.md#self-managed-billing-and-usage)
- [Billable users count](manage_users_and_seats.md#billable-users)
- GitLab version
- Hostname
- Instance ID
- Unique instance ID
Additionally, we also send add-on metrics such as:
- Add-on type
- Purchased seats
- Assigned seats
Example of a license sync request:
```json
{
"gitlab_version": "14.1.0-pre",
"timestamp": "2021-06-14T12:00:09Z",
"date": "2021-06-14",
"license_key": "XXX",
"max_historical_user_count": 75,
"billable_users_count": 75,
"hostname": "gitlab.example.com",
"instance_id": "9367590b-82ad-48cb-9da7-938134c29088",
"unique_instance_id": "a98bab6e-73e3-5689-a487-1e7b89a56901",
"add_on_metrics": [
{
"add_on_type": "duo_enterprise",
"purchased_seats": 100,
"assigned_seats": 50
}
]
}
```
## Link subscription to a group
{{< details >}}
- Tier: Premium, Ultimate
- Offering: GitLab.com
{{< /details >}}
To change the group linked to a GitLab.com subscription:
1. Sign in to the [Customers Portal](https://customers.gitlab.com/customers/sign_in) with a
[linked](customers_portal.md#link-a-gitlabcom-account) GitLab.com account.
1. Do one of the following:
- If the subscription is not linked to a group, select **Link subscription to a group**.
- If the subscription is already linked to a group, select **Subscription actions** ({{< icon name="ellipsis_v" >}}) > **Change linked group**.
1. Select the desired group from the **New Namespace** dropdown list. For a group to appear here, you must have the Owner role for that group.
1. If the [total number of users](manage_users_and_seats.md#view-seat-usage) in your group exceeds the number of seats in your subscription,
you are prompted to pay for the additional users. Subscription charges are calculated based on
the total number of users in a group, including its subgroups and nested projects.
If you purchased your subscription through an authorized reseller, you are unable to pay for additional users.
You can either:
- Remove additional users, so that no overage is detected.
- Contact the partner to purchase additional seats now or at the end of your subscription term.
1. Select **Confirm changes**.
Only one namespace can be linked to a subscription.
<i class="fa fa-youtube-play youtube" aria-hidden="true"></i>
For a demo, see [Linking GitLab Subscription to the Namespace](https://youtu.be/8iOsN8ajBUw).
## Add or change subscription contacts
Contacts can renew a subscription, cancel a subscription, or transfer the subscription to a different namespace.
You can [change profile owner information](customers_portal.md#change-profile-owner-information)
and [add another billing account manager](customers_portal.md#add-a-billing-account-manager).
### Transfer restrictions
You can change the linked namespace, however this is not supported for all subscription types.
You cannot transfer:
- An expired or trial subscription.
- A subscription with compute minutes which is already linked to a namespace.
- A subscription with a Premium or Ultimate plan to a namespace which already has a Premium or Ultimate plan.
- A subscription with a GitLab Duo add-on to a namespace which already has a subscriptions with a GitLab Duo add-on.
## Enterprise Agile Planning
{{< details >}}
- Tier: Ultimate
- Offering: GitLab.com, GitLab Self-Managed, GitLab Dedicated
{{< /details >}}
GitLab Enterprise Agile Planning is an add-on that helps bring non-technical users into the same
DevSecOps platform where engineers build, test, secure, and deploy code.
The add-on enables cross-team collaboration between developers and non-developers without having to
purchase full GitLab licenses for non-engineering team members.
With Enterprise Agile Planning seats, non-engineering team members can participate in planning
workflows, measure software delivery velocity and impact with Value Stream Analytics, and use
executive dashboards to drive organizational visibility.
To purchase additional Enterprise Agile Planning seats, contact your
[GitLab sales representative](https://customers.gitlab.com/contact_us) for more information.
|
---
stage: Fulfillment
group: Subscription Management
info: To determine the technical writer assigned to the Stage/Group associated with
this page, see https://handbook.gitlab.com/handbook/product/ux/technical-writing/#assignments
description: Buy, view, and renew your GitLab subscriptions.
title: Manage subscription
breadcrumbs:
- doc
- subscriptions
---
## Buy a subscription
You can buy a subscription for GitLab.com or GitLab Self-Managed.
The subscription determines which features are available for your private projects.
After you subscribe to GitLab, you can manage the details of your subscription.
If you experience any issues, see the [troubleshooting GitLab subscription](gitlab_com/gitlab_subscription_troubleshooting.md).
Organizations with public open source projects can apply to the [GitLab for Open Source program](community_programs.md#gitlab-for-open-source).
### For GitLab.com
{{< details >}}
- Tier: Premium, Ultimate
- Offering: GitLab.com
{{< /details >}}
GitLab.com is the GitLab multi-tenant software-as-a-service (SaaS) offering.
You don't need to install anything to use GitLab.com, you only need to [sign up](https://gitlab.com/users/sign_up).
When you sign up, you choose:
- [A subscription](https://about.gitlab.com/pricing/).
- The number of seats you want.
A GitLab.com subscription applies to a top-level group.
Members of every subgroup and project in the group:
- Can use the features of the subscription.
- Consume seats in the subscription.
To subscribe to GitLab.com:
1. View the [GitLab.com feature comparison](https://about.gitlab.com/pricing/feature-comparison/)
and decide which tier you want.
1. Create a user account for yourself by using the
[sign up page](https://gitlab.com/users/sign_up).
1. Create a [group](../user/group/_index.md#create-a-group). Your subscription tier applies to the top-level group, its subgroups, and projects.
1. Create additional users and
[add them to the group](../user/group/_index.md#add-users-to-a-group). The users in this group, its subgroups, and projects can use
the features of your subscription tier, and they consume a seat in your subscription.
1. On the left sidebar, select **Settings > Billing** and choose a tier. You are taken to the Customers Portal.
1. Fill out the form to complete your purchase.
### For GitLab Self-Managed
{{< details >}}
- Tier: Premium, Ultimate
- Offering: GitLab Self-Managed
{{< /details >}}
To subscribe to GitLab for a GitLab Self-Managed instance:
1. Go to the [Pricing page](https://about.gitlab.com/pricing/) and select a self-managed plan. You are redirected to the [Customers Portal](https://customers.gitlab.com/) to complete your purchase.
1. After purchase, an activation code is sent to the email address associated with the Customers Portal account.
You must [add this code to your GitLab instance](../administration/license.md).
{{< alert type="note" >}}
If you're purchasing a subscription for an existing **Free** GitLab Self-Managed
instance, ensure you're purchasing enough seats to
[cover your users](../administration/admin_area.md#administering-users).
{{< /alert >}}
## View subscription
### For GitLab.com
{{< details >}}
- Tier: Premium, Ultimate
- Offering: GitLab.com
{{< /details >}}
Prerequisites:
- You must have the Owner role for the group.
To see the status of your GitLab.com subscription:
1. On the left sidebar, select **Search or go to** and find your group.
1. Select **Settings > Billing**.
The following information is displayed:
| Field | Description |
|:----------------------------|:------------|
| **Seats in subscription** | If this is a paid plan, represents the number of seats you've bought for this group. |
| **Seats currently in use** | Number of seats in use. Select **See usage** to see a list of the users using these seats. |
| **Maximum seats used** | Highest number of seats you've used. |
| **Seats owed** | **Max seats used** minus **Seats in subscription**. |
| **Subscription start date** | Date your subscription started. |
| **Subscription end date** | Date your current subscription ends. |
### For GitLab Self-Managed
{{< details >}}
- Tier: Premium, Ultimate
- Offering: GitLab Self-Managed
{{< /details >}}
Prerequisites:
- You must be an administrator.
You can view the status of your subscription:
1. On the left sidebar, at the bottom, select **Admin**.
1. Select **Subscription**.
The **Subscription** page includes the following information:
- Licensee
- Plan
- When it was uploaded, started, and when it expires
- Number of users in subscription
- Number of billable users
- Maximum users
- Number of users over subscription
## Review your account
You should regularly review your billing account settings and purchasing information.
To review your billing account settings:
1. Sign in to the [Customers Portal](https://customers.gitlab.com/customers/sign_in).
1. Select **Billing account settings**.
1. Verify or update:
- Under **Payment methods**, the credit card on file.
- Under **Company information**, the subscription and billing contact details.
1. Save any changes.
You should also regularly review your user accounts to make sure that you are only
renewing for the correct number of active billable users. Inactive user accounts:
- Might count as billable users. You pay more than
you should if you renew inactive user accounts.
- Can be a security risk. A regular review helps reduce this risk.
For more information, see the documentation on:
- [User statistics](../administration/admin_area.md#users-statistics).
- [Managing users and subscription seats](manage_users_and_seats.md#manage-users-and-subscription-seats).
## Upgrade subscription tier
{{< details >}}
- Tier: Premium, Ultimate
- Offering: GitLab.com, GitLab Self-Managed
{{< /details >}}
To upgrade your [GitLab tier](https://about.gitlab.com/pricing/):
1. Sign in to the [Customers Portal](https://customers.gitlab.com/customers/sign_in).
1. Select **Upgrade plan** on the relevant subscription card.
1. Confirm the active form of payment, or add a new form of payment.
1. Select the **I accept the Privacy Statement and Terms of Service** checkbox.
1. Select **Upgrade subscription**.
The following is emailed to you:
- A payment receipt. You can also access this information in the Customers Portal under
[**Invoices**](https://customers.gitlab.com/invoices).
- On GitLab Self-Managed, a new activation code for your license.
On GitLab Self-Managed, the new tier takes effect on the next subscription sync.
You can also [synchronize your subscription manually](#subscription-data-synchronization)
to upgrade right away.
## Renew subscription
{{< details >}}
- Tier: Premium, Ultimate
- Offering: GitLab.com, GitLab Self-Managed
{{< /details >}}
Before your subscription renewal date, you should review your account to check
your current seat usage and billable users.
You can renew your subscription automatically or manually.
You should renew your subscription manually if you want to either:
- Renew for fewer seats.
- Increase or decrease the quantities of products being renewed.
- Remove add-on products no longer needed for the renewed subscription term.
- Upgrade the subscription tier.
The renewal period start date is displayed on the group Billing page under **Next subscription term start date**.
Contact the:
- [Support team](https://support.gitlab.com/hc/en-us/requests/new?ticket_form_id=360000071293)
if you need help accessing the Customers Portal or changing the contact person who manages your subscription.
- [Sales team](https://customers.gitlab.com/contact_us) if you need help renewing your subscription.
### Check when subscription expires
15 days before a subscription expires, a banner with the subscription expiry date displays for
administrators in the GitLab user interface.
You cannot manually renew your subscription more than 15 days before the subscription
expires. To check when you can renew:
1. Sign in to the [Customers Portal](https://customers.gitlab.com/customers/sign_in).
1. Select **Subscription actions** ({{< icon name="ellipsis_v" >}}), then select **Renew subscription**
to view the date you can renew.
### Renew automatically
Prerequisites:
- For GitLab Self-Managed, you must [synchronize subscription data](#subscription-data-synchronization) and review your account at least two days before renewal to ensure your changes are synchronized.
When a subscription is set to auto-renew, it renews automatically at midnight UTC on the expiration date without a gap in available service.
You receive [email notifications](#renewal-notifications) before a subscription automatically renews.
Subscriptions purchased through the Customers Portal are set to auto-renew by default,
but you can [turn off automatic subscription renewal](#turn-on-or-turn-off-automatic-subscription-renewal).
The number of user seats is adjusted to fit the number of billable users in your
[group](manage_users_and_seats.md#view-seat-usage) or [instance](manage_users_and_seats.md#view-users)
at the time of renewal, if that number is higher than the current subscription quantity.
#### Turn on or turn off automatic subscription renewal
You can use the Customers Portal to turn on or turn off automatic subscription renewal:
1. Sign in to the [Customers Portal](https://customers.gitlab.com/customers/sign_in).
You are taken to the **Subscriptions & purchases** page.
1. Check the subscription card:
- If the card displays **Expires on DATE**, your subscription is not
set to automatically renew. To enable automatic renewal, in
**Subscription actions** ({{< icon name="ellipsis_v" >}}), select **Turn on auto-renew**.
- If the card displays **Auto-renews on DATE**, your subscription is set to
automatically renew. To disable automatic renewal:
1. In **Subscription actions** ({{< icon name="ellipsis_v" >}}), select **Cancel subscription**.
1. Select a reason for canceling.
1. Optional: In **Would you like to add anything?**, enter any relevant information.
1. Select **Cancel subscription**.
### Renew manually
To manually renew your subscription:
1. Determine the number of users you need in the next subscription period.
1. Sign in to the [Customers Portal](https://customers.gitlab.com/customers/sign_in).
1. Under your existing subscription, select **Renew**. This button does not display
until 15 days before the subscription expires.
1. If renewing Premium or Ultimate products, in the **Seats** text box, enter the
total number of user seats you need for the upcoming year.
{{< alert type="note" >}}
Make sure this number is equal to, or greater than
the number of [billable users](manage_users_and_seats.md#billable-users) in the system at the time of renewal.
{{< /alert >}}
1. Optional. For GitLab Self-Managed, if the maximum number of users in your instance exceeded the number
you were licensed for in the previous subscription term, the
[overage](quarterly_reconciliation.md) is due when you renew.
In the **Users over license** text box, enter the number of
[users over subscription](manage_users_and_seats.md#users-over-subscription) for the user overage incurred.
1. Optional. If renewing add-on products, review and update the desired quantity. You can also remove products.
1. Optional. If upgrading the subscription tier, select the desired option.
1. Review your renewal details and select **Renew subscription** to complete the
payment process.
1. For GitLab Self-Managed, on the [Subscriptions & purchases](https://customers.gitlab.com/subscriptions)
page on the relevant subscription card, select **Copy activation code** to get
a copy of the renewal term activation code, and [add the activation code](../administration/license.md) to your instance.
To add products to your subscription, [contact the sales team](https://customers.gitlab.com/contact_us).
### Renew for fewer seats
Subscription renewals with fewer seats must have or exceed the current number of billable users.
Before you renew your subscription:
- For GitLab.com,
[reduce the number of billable users](manage_users_and_seats.md#remove-users-from-subscription)
if it exceeds the number of seats you want to renew for.
- For GitLab Self-Managed, [block inactive or unwanted users](../administration/moderate_users.md#block-a-user).
To manually renew your subscription for fewer seats, you can either:
- [Manually renew](#renew-manually) within 15 days of the
subscription renewal date. Ensure that you specify the seat quantity when you renew.
- [Turn off automatic renewal of your subscription](#turn-on-or-turn-off-automatic-subscription-renewal),
and contact the [sales team](https://customers.gitlab.com/contact_us) to renew it for the number of seats you want.
### Renewal notifications
15 days before a subscription automatically renews, an email is sent with information
about the renewal.
- If your credit card is expired, the email tells you how to update it.
- If you have any outstanding overages or your subscription is not able to automatically
renew for any other reason, the email tells you to contact our Sales team or
manually renew in the Customers Portal.
- If there are no issues, the email specifies the:
- Names and quantity of the products being renewed.
- Total amount you owe. If your usage increases before renewal, this amount changes.
### Manage renewal invoice
An invoice is generated for your renewal. To view or download this renewal invoice,
go to the [Customers Portal invoices page](https://customers.gitlab.com/invoices).
If your account has a [saved credit card](customers_portal.md#change-your-payment-method),
the card is charged for the invoice amount.
If we are unable to process a payment or the auto-renewal fails for any other reason,
you have 14 days to renew your subscription, after which your GitLab tier is downgraded.
## Expired subscription
Subscriptions expire at the start of the expiration date, 00:00 server time.
For example, if a subscription is valid from January 1, 2024 until January 1, 2025:
- It expires at 11:59:59 PM UTC December 31, 2024.
- It is considered expired from 12:00:00 AM UTC January 1, 2025.
- The grace period of 14 days starts at 12:00:00 AM UTC January 1, 2025 and ends at 11:59:59 PM UTC January 14, 2025.
### For GitLab.com
{{< details >}}
- Tier: Premium, Ultimate
- Offering: GitLab.com
{{< /details >}}
When your subscription expires, you can continue to use paid features of GitLab for 14 days.
After 14 days, paid features are no longer available, but you can continue to use free features.
To resume paid feature functionality, purchase a new subscription.
### For GitLab Self-Managed
{{< details >}}
- Tier: Premium, Ultimate
- Offering: GitLab Self-Managed
{{< /details >}}
When your license expires, after a 14 day grace period:
- Your instance becomes read-only.
- GitLab locks features, such as Git pushes and issue creation.
- An expiration message is displayed to all instance administrators.
After your license has expired:
- To resume functionality,
[activate a new subscription](../administration/license_file.md#activate-subscription-during-installation).
- To keep using Free tier features only,
[remove the expired license](../administration/license_file.md#remove-a-license).
## Subscription data synchronization
{{< details >}}
- Tier: Premium, Ultimate
- Offering: GitLab Self-Managed
{{< /details >}}
Prerequisites:
- GitLab Enterprise Edition (EE).
- Connection to the internet, and must not have an offline environment.
- [Activated](../administration/license.md) your instance with an activation code.
Your [subscription data](#subscription-data) is automatically synchronized once
a day between your GitLab Self-Managed instance and GitLab.
At approximately 3:00 AM (UTC), this daily synchronization job sends
[subscription data](#subscription-data) to the Customers Portal. For this reason,
updates and renewals might not apply immediately.
The data is sent securely through an encrypted HTTPS connection to
`customers.gitlab.com` on port `443`. If the job fails, it retries up to 12 times
over approximately 17 hours.
After you have set up automatic data synchronization, the following processes are
also automated.
- [Quarterly subscription reconciliation](quarterly_reconciliation.md).
- Subscription renewals.
- Subscription updates, such as adding more seats or upgrading a GitLab tier.
### Manually synchronize subscription data
You can also manually synchronize subscription data at any time.
1. On the left sidebar, at the bottom, select **Admin**.
1. Select **Subscription**.
1. In the **Subscription details** section, select **Sync** ({{< icon name="retry" >}}).
A synchronization job is then queued. When the job finishes, the subscription
details are updated.
### Subscription data
{{< history >}}
- Unique instance ID [introduced](https://gitlab.com/gitlab-org/gitlab/-/merge_requests/189399) in GitLab 18.1.
{{< /history >}}
The daily synchronization job sends the following information to the
Customers Portal:
- Date
- Timestamp
- License key, with the following encrypted within the key:
- Company name
- Licensee name
- Licensee email
- Historical [maximum user count](manage_users_and_seats.md#self-managed-billing-and-usage)
- [Billable users count](manage_users_and_seats.md#billable-users)
- GitLab version
- Hostname
- Instance ID
- Unique instance ID
Additionally, we also send add-on metrics such as:
- Add-on type
- Purchased seats
- Assigned seats
Example of a license sync request:
```json
{
"gitlab_version": "14.1.0-pre",
"timestamp": "2021-06-14T12:00:09Z",
"date": "2021-06-14",
"license_key": "XXX",
"max_historical_user_count": 75,
"billable_users_count": 75,
"hostname": "gitlab.example.com",
"instance_id": "9367590b-82ad-48cb-9da7-938134c29088",
"unique_instance_id": "a98bab6e-73e3-5689-a487-1e7b89a56901",
"add_on_metrics": [
{
"add_on_type": "duo_enterprise",
"purchased_seats": 100,
"assigned_seats": 50
}
]
}
```
## Link subscription to a group
{{< details >}}
- Tier: Premium, Ultimate
- Offering: GitLab.com
{{< /details >}}
To change the group linked to a GitLab.com subscription:
1. Sign in to the [Customers Portal](https://customers.gitlab.com/customers/sign_in) with a
[linked](customers_portal.md#link-a-gitlabcom-account) GitLab.com account.
1. Do one of the following:
- If the subscription is not linked to a group, select **Link subscription to a group**.
- If the subscription is already linked to a group, select **Subscription actions** ({{< icon name="ellipsis_v" >}}) > **Change linked group**.
1. Select the desired group from the **New Namespace** dropdown list. For a group to appear here, you must have the Owner role for that group.
1. If the [total number of users](manage_users_and_seats.md#view-seat-usage) in your group exceeds the number of seats in your subscription,
you are prompted to pay for the additional users. Subscription charges are calculated based on
the total number of users in a group, including its subgroups and nested projects.
If you purchased your subscription through an authorized reseller, you are unable to pay for additional users.
You can either:
- Remove additional users, so that no overage is detected.
- Contact the partner to purchase additional seats now or at the end of your subscription term.
1. Select **Confirm changes**.
Only one namespace can be linked to a subscription.
<i class="fa fa-youtube-play youtube" aria-hidden="true"></i>
For a demo, see [Linking GitLab Subscription to the Namespace](https://youtu.be/8iOsN8ajBUw).
## Add or change subscription contacts
Contacts can renew a subscription, cancel a subscription, or transfer the subscription to a different namespace.
You can [change profile owner information](customers_portal.md#change-profile-owner-information)
and [add another billing account manager](customers_portal.md#add-a-billing-account-manager).
### Transfer restrictions
You can change the linked namespace, however this is not supported for all subscription types.
You cannot transfer:
- An expired or trial subscription.
- A subscription with compute minutes which is already linked to a namespace.
- A subscription with a Premium or Ultimate plan to a namespace which already has a Premium or Ultimate plan.
- A subscription with a GitLab Duo add-on to a namespace which already has a subscriptions with a GitLab Duo add-on.
## Enterprise Agile Planning
{{< details >}}
- Tier: Ultimate
- Offering: GitLab.com, GitLab Self-Managed, GitLab Dedicated
{{< /details >}}
GitLab Enterprise Agile Planning is an add-on that helps bring non-technical users into the same
DevSecOps platform where engineers build, test, secure, and deploy code.
The add-on enables cross-team collaboration between developers and non-developers without having to
purchase full GitLab licenses for non-engineering team members.
With Enterprise Agile Planning seats, non-engineering team members can participate in planning
workflows, measure software delivery velocity and impact with Value Stream Analytics, and use
executive dashboards to drive organizational visibility.
To purchase additional Enterprise Agile Planning seats, contact your
[GitLab sales representative](https://customers.gitlab.com/contact_us) for more information.
|
https://docs.gitlab.com/manage_users_and_seats
|
https://gitlab.com/gitlab-org/gitlab/-/tree/master/doc/manage_users_and_seats.md
|
2025-08-13
|
doc/subscriptions
|
[
"doc",
"subscriptions"
] |
manage_users_and_seats.md
|
Fulfillment
|
Seat Management
|
To determine the technical writer assigned to the Stage/Group associated with this page, see https://handbook.gitlab.com/handbook/product/ux/technical-writing/#assignments
|
Manage users and seats
|
Manage users and seats associated with your GitLab subscription.
|
{{< details >}}
- Tier: Premium, Ultimate
- Offering: GitLab.com, GitLab Self-Managed, GitLab Dedicated
{{< /details >}}
## Billable users
Billable users are users with access to a namespace in a subscription, such as direct [members](../user/project/members/_index.md#membership-types),
inherited members, and invited users, with one of the following roles:
- Guest (billable on Premium, non-billable on Free and Ultimate)
- Planner
- Reporter
- Developer
- Maintainer
- Owner
Billable users count toward the number of seats purchased in your subscription.
The number of billable users changes when you block, deactivate, or add
users to your instance or group during your current subscription period.
If a user is in multiple groups or projects that belong to the same top-level group that holds the subscription, they are counted only once.
Seat usage is reviewed [quarterly or annually](quarterly_reconciliation.md).
On GitLab Self-Managed, the amount of **Billable users** is reported once a day in the **Admin** area.
On GitLab.com, subscription features apply only within the top-level group the subscription applies to. If
a user views or selects a different top-level group (one they have created themselves, for example)
and that group does not have a paid subscription, the user does not see any of the paid features.
A user can belong to two different top-level groups with different subscriptions.
In this case, the user sees only the features available to that subscription.
To prevent unexpectedly adding new billable users, which may result in overage fees, you should:
- [Prevent inviting groups outside the group hierarchy](../user/project/members/sharing_projects_groups.md#prevent-inviting-groups-outside-the-group-hierarchy).
- [Turn on restricted access](../user/group/manage.md#turn-on-restricted-access).
## Criteria for non-billable users
A user is not counted as a billable user if:
- They are pending approval.
- They are [deactivated](../administration/moderate_users.md#deactivate-a-user),
[banned](../user/group/moderate_users.md#ban-a-user),
or [blocked](../administration/moderate_users.md#block-a-user).
- They are not a member of any projects or groups (Ultimate subscriptions only).
- They have only the [Guest role](#free-guest-users) (Ultimate subscriptions only).
- They have only the [Minimal Access role](../user/permissions.md#users-with-minimal-access) for any GitLab.com subscriptions.
- The account is a GitLab-created service account:
- [Ghost User](../user/profile/account/delete_account.md#associated-records).
- Bots:
- [Support Bot](../user/project/service_desk/configure.md#support-bot-user).
- [Bot users for projects](../user/project/settings/project_access_tokens.md#bot-users-for-projects).
- [Bot users for groups](../user/group/settings/group_access_tokens.md#bot-users-for-groups).
- Other [internal users](../administration/internal_users.md).
## Free Guest users
{{< details >}}
- Tier: Ultimate
{{< /details >}}
In the **Ultimate** tier, users who are assigned the Guest role do not consume a seat.
The user must not be assigned any other role, anywhere in the instance for GitLab Self-Managed or in the namespace for GitLab.com.
- If your project is:
- Private or internal, a user with the Guest role has [a set of permissions](../user/permissions.md#project-members-permissions).
- Public, all users, including those with the Guest role, can access your project.
- For GitLab.com, if a user with the Guest role creates a project in their personal namespace, the user does not consume a seat.
The project is under the user's personal namespace and does not relate to the group with the Ultimate subscription.
- On GitLab Self-Managed, a user's highest assigned role is updated asynchronously and may take some time to update.
{{< alert type="note" >}}
On GitLab Self-Managed, if a user creates a project, they are assigned the Maintainer or Owner role.
To prevent a user from creating projects, as an administrator, you can mark the user
as [external](../administration/external_users.md).
{{< /alert >}}
## Buy more seats
{{< details >}}
- Offering: GitLab.com, GitLab Self-Managed
{{< /details >}}
Your subscription cost is based on the maximum number of seats you use during the billing period.
If [restricted access](../user/group/manage.md#turn-on-restricted-access) is:
- On, when there are no seats left in your subscription you must purchase more seats for groups to add new billable users.
- Off, when there are no seats left in your subscription groups can continue to add billable users.
GitLab [bills you for the overage](quarterly_reconciliation.md).
You cannot buy seats for your subscription if either:
- You purchased your subscription through an [authorized reseller](customers_portal.md#subscription-purchased-through-a-reseller) (including GCP and AWS marketplaces). Contact the reseller to add more seats.
- You have a multi-year subscription. Contact the [sales team](https://customers.gitlab.com/contact_us) to add more seats.
To buy seats for a subscription:
1. Sign in to the [Customers Portal](https://customers.gitlab.com/).
1. Go to the **Subscriptions & purchases** page.
1. Select **Add seats** on the relevant subscription card.
1. Enter the number of additional users.
1. Review the **Purchase summary** section. The system lists the total price for all users on the system and a credit for what you've already paid. You are only charged for the net change.
1. Enter your payment information.
1. Check the **I accept the Privacy Statement and Terms of Service** checkbox.
1. Select **Purchase seats**.
You receive the payment receipt by email.
You can also access the receipt in the Customers Portal under [**Invoices**](https://customers.gitlab.com/invoices).
## Reduce seats
You can reduce seats only during subscription renewal.
If you want to reduce the number of seats in your subscription, you can [renew for fewer seats](manage_subscription.md#renew-for-fewer-seats).
If you want to reduce seats after you have renewed or purchased a subscription,
open a ticket with the Billing team or contact your GitLab sales representative.
For assistance, visit the [Contact us](https://customers.gitlab.com/contact_us) page in your Customers Portal account.
## Self-Managed billing and usage
{{< details >}}
- Offering: GitLab Self-Managed
{{< /details >}}
A GitLab Self-Managed subscription uses a hybrid model. You pay for a subscription
according to the maximum number of users enabled during the
subscription period.
For instances that are not offline or on a closed network, the maximum number of
simultaneous users in the GitLab Self-Managed instance is checked each quarter.
If an instance is unable to generate a quarterly usage report, the existing
true up model is used. Prorated charges are not
possible without a quarterly usage report.
The number of users in subscription represents the number of users included in your current license,
based on what you've paid for.
This number remains the same throughout your subscription period unless you purchase more seats.
The number of maximum users reflects the highest number of billable users on your system for the current license period.
### Users over subscription
A GitLab subscription is valid for a specific number of seats.
The number of users over subscription shows how many users are in excess of the
number allowed by the subscription, in the current subscription period.
Calculated as `Maximum users` - `Users in subscription` for the current license
term. For example, you purchase a subscription for 10 users.
| Event | Billable users | Maximum users |
|:---------------------------------------------------|:-----------------|:--------------|
| Ten users occupy all 10 seats. | 10 | 10 |
| Two new users join. | 12 | 12 |
| Three users leave and their accounts are blocked. | 9 | 12 |
| Four new users join. | 13 | 13 |
Users over subscription = 13 - 10 (Maximum users - users in license)
The users over subscription value is always zero for trial license.
If users over subscription value is above zero, then you have more users in your
GitLab instance than you are licensed for. You must pay for the additional users
[before or at the time of renewal](quarterly_reconciliation.md). This is
called the "true up" process. If you do not do this, your license key does not work.
To view the number of users over subscription, go to the **Admin** area.
### View users
View the lists of users in your instance:
1. On the left sidebar, at the bottom, select **Admin**.
1. Select **Users**.
Select a user to view their account information.
#### Check daily and historical billable users
Prerequisites:
- You must be an administrator.
You can get a list of daily and historical billable users in your GitLab instance:
1. [Start a Rails console session](../administration/operations/rails_console.md#starting-a-rails-console-session).
1. Count the number of users in the instance:
```ruby
User.billable.count
```
1. Get the historical maximum number of users on the instance from the past year:
```ruby
::HistoricalData.max_historical_user_count(from: 1.year.ago.beginning_of_day, to: Time.current.end_of_day)
```
#### Update daily and historical billable users
Prerequisites:
- You must be an administrator.
You can trigger a manual update of the daily and historical billable users in your GitLab instance.
1. [Start a Rails console session](../administration/operations/rails_console.md#starting-a-rails-console-session).
1. Force an update of the daily billable users:
```ruby
identifier = Analytics::UsageTrends::Measurement.identifiers[:billable_users]
::Analytics::UsageTrends::CounterJobWorker.new.perform(identifier, User.minimum(:id), User.maximum(:id), Time.zone.now)
```
1. Force an update of the historical max billable users:
```ruby
::HistoricalDataWorker.new.perform
```
### Manage users and subscription seats
Managing the number of users against the number of subscription seats can be difficult:
- If [LDAP is integrated with GitLab](../administration/auth/ldap/_index.md), anyone
in the configured domain can sign up for a GitLab account. This can result in
an unexpected bill at time of renewal.
- If sign-up is turned on in your instance, anyone who can access the instance can
sign up for an account.
GitLab has several features to help you manage the number of users. You can:
- [Require administrator approval for new sign ups](../administration/settings/sign_up_restrictions.md#require-administrator-approval-for-new-sign-ups).
- Automatically block new users, either through
[LDAP](../administration/auth/ldap/_index.md#basic-configuration-settings) or
[OmniAuth](../integration/omniauth.md#configure-common-settings).
- [Limit the number of billable users](../administration/settings/sign_up_restrictions.md#user-cap)
who can sign up or be added to a subscription without administrator approval.
- [Disable new sign-ups](../administration/settings/sign_up_restrictions.md),
and instead manage new users manually.
- View a breakdown of users by role in the
[Users statistics](../administration/admin_area.md#users-statistics) page.
To increase the number of users covered by your license, [buy more seats](#buy-more-seats)
during the subscription period. The cost of seats added during the subscription
period is prorated from the date of purchase through to the end of the subscription
period. You can continue to add users even if you reach the number of users in
license count. GitLab [bills you for the overage](quarterly_reconciliation.md).
If your subscription was activated with an activation code, the additional seats are reflected in
your instance immediately. If you're using a license file, you receive an updated file.
To add the seats, [add the license file](../administration/license_file.md)
to your instance.
### Export license usage
Prerequisites:
- You must be an administrator.
You can export your license usage into a CSV file.
This file contains the information GitLab uses to manually process
[quarterly reconciliations](quarterly_reconciliation.md)
and [renewals](manage_subscription.md#renew-subscription). If your instance is firewalled or an
offline environment, you must provide GitLab with this information.
{{< alert type="warning" >}}
Do not open the license usage file. If you open the file, failures might occur when [you submit your license usage data](../administration/license_file.md#submit-license-usage-data).
{{< /alert >}}
1. On the left sidebar, at the bottom, select **Admin**.
1. Select **Subscription**.
1. In the upper-right corner, select **Export license usage file**.
#### License usage file contents
The license usage file includes the following information:
- License key
- Licensee email
- License start date (UTC)
- License end date (UTC)
- Company
- Timestamp the file was generated at and exported (UTC)
- Table of historical user counts for each day in the period:
- Timestamp the count was recorded (UTC)
- Billable user count
{{< alert type="note" >}}
A custom format is used for [dates](https://gitlab.com/gitlab-org/gitlab/blob/3be39f19ac3412c089be28553e6f91b681e5d739/config/initializers/date_time_formats.rb#L7) and [times](https://gitlab.com/gitlab-org/gitlab/blob/3be39f19ac3412c089be28553e6f91b681e5d739/config/initializers/date_time_formats.rb#L13) in CSV files.
{{< /alert >}}
## GitLab.com billing and usage
{{< details >}}
- Offering: GitLab.com
{{< /details >}}
A GitLab.com subscription uses a concurrent (_seat_) model.
You pay for a subscription according to the maximum number of users assigned to the top-level group,
its subgroups and projects during the billing period.
You can add and remove users during the subscription period without incurring additional charges,
as long as the total users at any given time doesn't exceed the subscription count.
If the total users exceeds your subscription count, you will incur an overage,
which must be paid at your next [reconciliation](quarterly_reconciliation.md).
A top-level group can be [changed](../user/group/manage.md#change-a-groups-path) like any other group.
### Seats owed
If the number of billable users exceeds the number of **seats in subscription**, known
as the number of **seats owed**, you must pay for the excess number of users.
For example, if you purchase a subscription for 10 users:
| Event | Billable members | Maximum users |
|:---------------------------------------------------|:-----------------|:--------------|
| Ten users occupy all 10 seats. | 10 | 10 |
| Two new users join. | 12 | 12 |
| Three users leave and their accounts are removed. | 9 | 12 |
Seats owed = 12 - 10 (Maximum users - users in subscription)
To prevent charges from seats owed, you can
[turn on restricted access](../user/group/manage.md#turn-on-restricted-access).
This setting restricts groups from adding new billable users when there are no seats left in the subscription.
### Seat usage alerts
{{< history >}}
- [Introduced](https://gitlab.com/gitlab-org/gitlab/-/issues/348481) in GitLab 15.2 [with a flag](../administration/feature_flags/_index.md) named `seat_flag_alerts`.
- [Generally available](https://gitlab.com/gitlab-org/gitlab/-/issues/362041) in GitLab 15.4. Feature flag `seat_flag_alerts` removed.
{{< /history >}}
If you have the Owner role for the top-level group, an alert notifies you
of your total seat usage.
The alert displays on group, subgroup, and project
pages, and only for top-level groups linked to subscriptions enrolled
in [quarterly subscription reconciliations](quarterly_reconciliation.md).
After you dismiss the alert, it doesn't display until another seat is used.
The alert displays based on the following seat usage. You cannot configure the
amounts at which the alert displays.
| Seats in subscription | Alert displays when |
|-----------------------|---------------------|
| 0-15 | One seat remains. |
| 16-25 | Two seats remain. |
| 26-99 | 10% of seats remain.|
| 100-999 | 8% of seats remain. |
| 1000+ | 5% of seats remain. |
### View seat usage
To view a list of seats being used:
1. On the left sidebar, select **Search or go to** and find your group.
1. Select **Settings > Usage quotas**.
1. Select the **Seats** tab.
For each user, a list shows groups and projects where the user is a direct member.
- **Group invite** indicates the user is a member of a [group invited to a group](../user/project/members/sharing_projects_groups.md#invite-a-group-to-a-group).
- **Project invite** indicates the user is a member of a [group invited to a project](../user/project/members/sharing_projects_groups.md#invite-a-group-to-a-project).
The data in seat usage listing, **Seats in use**, and **Seats in subscription** are updated live.
The counts for **Max seats used** and **Seats owed** are updated once per day.
#### View billing information
To view your subscription information and a summary of seat counts:
1. On the left sidebar, select **Search or go to** and find your group.
1. Select **Settings > Billing**.
- The usage statistics are updated once per day, which may cause a difference between the information
in the **Usage quotas** page and the **Billing page**.
- The **Last login** field is updated when a user signs in after they have signed out. If there is an active session
when a user re-authenticates (for example, after a 24 hour SAML session timeout), this field is not updated.
### Search seat usage
To search seat usage:
1. On the left sidebar, select **Search or go to** and find your group.
1. Select **Settings > Usage quotas**.
1. On the **Seats** tab, enter a string in the search field. A minimum of 3 characters are required.
The search returns users whose first name, last name, or username contain the search string.
For example:
| First name | Search string | Match ? |
|:-----------|:--------------|:--------|
| Amir | `ami` | Yes |
| Amir | `amr` | No |
### Export seat usage
To export seat usage data as a CSV file:
1. On the left sidebar, select **Search or go to** and find your group.
1. Select **Settings > Usage quotas**.
1. In the **Seats** tab, select **Export list**.
### Export seat usage history
Prerequisites:
- You must have the Owner role for the group.
To export seat usage history as a CSV file:
1. On the left sidebar, select **Search or go to** and find your group.
1. Select **Settings > Usage quotas**.
1. In the **Seats** tab, select **Export seat usage history**.
The generated list contains all seats being used,
and is not affected by the current search.
### Remove users from subscription
To remove a billable user from your GitLab.com subscription:
1. On the left sidebar, select **Search or go to** and find your group.
1. Select **Settings > Billing**.
1. In the **Seats currently in use** section, select **See usage**.
1. In the row for the user you want to remove, on the right side, select **Remove user**.
1. Re-type the username and select **Remove user**.
If you add a member to a group by using the [share a group with another group](../user/project/members/sharing_projects_groups.md#invite-a-group-to-a-group) feature, you can't remove the member by using this method. Instead, you can either:
- [Remove the member from the shared group](../user/group/_index.md#remove-a-member-from-the-group).
- [Remove the invited group](../user/project/members/sharing_projects_groups.md#remove-an-invited-group).
|
---
stage: Fulfillment
group: Seat Management
info: To determine the technical writer assigned to the Stage/Group associated with
this page, see https://handbook.gitlab.com/handbook/product/ux/technical-writing/#assignments
description: Manage users and seats associated with your GitLab subscription.
title: Manage users and seats
breadcrumbs:
- doc
- subscriptions
---
{{< details >}}
- Tier: Premium, Ultimate
- Offering: GitLab.com, GitLab Self-Managed, GitLab Dedicated
{{< /details >}}
## Billable users
Billable users are users with access to a namespace in a subscription, such as direct [members](../user/project/members/_index.md#membership-types),
inherited members, and invited users, with one of the following roles:
- Guest (billable on Premium, non-billable on Free and Ultimate)
- Planner
- Reporter
- Developer
- Maintainer
- Owner
Billable users count toward the number of seats purchased in your subscription.
The number of billable users changes when you block, deactivate, or add
users to your instance or group during your current subscription period.
If a user is in multiple groups or projects that belong to the same top-level group that holds the subscription, they are counted only once.
Seat usage is reviewed [quarterly or annually](quarterly_reconciliation.md).
On GitLab Self-Managed, the amount of **Billable users** is reported once a day in the **Admin** area.
On GitLab.com, subscription features apply only within the top-level group the subscription applies to. If
a user views or selects a different top-level group (one they have created themselves, for example)
and that group does not have a paid subscription, the user does not see any of the paid features.
A user can belong to two different top-level groups with different subscriptions.
In this case, the user sees only the features available to that subscription.
To prevent unexpectedly adding new billable users, which may result in overage fees, you should:
- [Prevent inviting groups outside the group hierarchy](../user/project/members/sharing_projects_groups.md#prevent-inviting-groups-outside-the-group-hierarchy).
- [Turn on restricted access](../user/group/manage.md#turn-on-restricted-access).
## Criteria for non-billable users
A user is not counted as a billable user if:
- They are pending approval.
- They are [deactivated](../administration/moderate_users.md#deactivate-a-user),
[banned](../user/group/moderate_users.md#ban-a-user),
or [blocked](../administration/moderate_users.md#block-a-user).
- They are not a member of any projects or groups (Ultimate subscriptions only).
- They have only the [Guest role](#free-guest-users) (Ultimate subscriptions only).
- They have only the [Minimal Access role](../user/permissions.md#users-with-minimal-access) for any GitLab.com subscriptions.
- The account is a GitLab-created service account:
- [Ghost User](../user/profile/account/delete_account.md#associated-records).
- Bots:
- [Support Bot](../user/project/service_desk/configure.md#support-bot-user).
- [Bot users for projects](../user/project/settings/project_access_tokens.md#bot-users-for-projects).
- [Bot users for groups](../user/group/settings/group_access_tokens.md#bot-users-for-groups).
- Other [internal users](../administration/internal_users.md).
## Free Guest users
{{< details >}}
- Tier: Ultimate
{{< /details >}}
In the **Ultimate** tier, users who are assigned the Guest role do not consume a seat.
The user must not be assigned any other role, anywhere in the instance for GitLab Self-Managed or in the namespace for GitLab.com.
- If your project is:
- Private or internal, a user with the Guest role has [a set of permissions](../user/permissions.md#project-members-permissions).
- Public, all users, including those with the Guest role, can access your project.
- For GitLab.com, if a user with the Guest role creates a project in their personal namespace, the user does not consume a seat.
The project is under the user's personal namespace and does not relate to the group with the Ultimate subscription.
- On GitLab Self-Managed, a user's highest assigned role is updated asynchronously and may take some time to update.
{{< alert type="note" >}}
On GitLab Self-Managed, if a user creates a project, they are assigned the Maintainer or Owner role.
To prevent a user from creating projects, as an administrator, you can mark the user
as [external](../administration/external_users.md).
{{< /alert >}}
## Buy more seats
{{< details >}}
- Offering: GitLab.com, GitLab Self-Managed
{{< /details >}}
Your subscription cost is based on the maximum number of seats you use during the billing period.
If [restricted access](../user/group/manage.md#turn-on-restricted-access) is:
- On, when there are no seats left in your subscription you must purchase more seats for groups to add new billable users.
- Off, when there are no seats left in your subscription groups can continue to add billable users.
GitLab [bills you for the overage](quarterly_reconciliation.md).
You cannot buy seats for your subscription if either:
- You purchased your subscription through an [authorized reseller](customers_portal.md#subscription-purchased-through-a-reseller) (including GCP and AWS marketplaces). Contact the reseller to add more seats.
- You have a multi-year subscription. Contact the [sales team](https://customers.gitlab.com/contact_us) to add more seats.
To buy seats for a subscription:
1. Sign in to the [Customers Portal](https://customers.gitlab.com/).
1. Go to the **Subscriptions & purchases** page.
1. Select **Add seats** on the relevant subscription card.
1. Enter the number of additional users.
1. Review the **Purchase summary** section. The system lists the total price for all users on the system and a credit for what you've already paid. You are only charged for the net change.
1. Enter your payment information.
1. Check the **I accept the Privacy Statement and Terms of Service** checkbox.
1. Select **Purchase seats**.
You receive the payment receipt by email.
You can also access the receipt in the Customers Portal under [**Invoices**](https://customers.gitlab.com/invoices).
## Reduce seats
You can reduce seats only during subscription renewal.
If you want to reduce the number of seats in your subscription, you can [renew for fewer seats](manage_subscription.md#renew-for-fewer-seats).
If you want to reduce seats after you have renewed or purchased a subscription,
open a ticket with the Billing team or contact your GitLab sales representative.
For assistance, visit the [Contact us](https://customers.gitlab.com/contact_us) page in your Customers Portal account.
## Self-Managed billing and usage
{{< details >}}
- Offering: GitLab Self-Managed
{{< /details >}}
A GitLab Self-Managed subscription uses a hybrid model. You pay for a subscription
according to the maximum number of users enabled during the
subscription period.
For instances that are not offline or on a closed network, the maximum number of
simultaneous users in the GitLab Self-Managed instance is checked each quarter.
If an instance is unable to generate a quarterly usage report, the existing
true up model is used. Prorated charges are not
possible without a quarterly usage report.
The number of users in subscription represents the number of users included in your current license,
based on what you've paid for.
This number remains the same throughout your subscription period unless you purchase more seats.
The number of maximum users reflects the highest number of billable users on your system for the current license period.
### Users over subscription
A GitLab subscription is valid for a specific number of seats.
The number of users over subscription shows how many users are in excess of the
number allowed by the subscription, in the current subscription period.
Calculated as `Maximum users` - `Users in subscription` for the current license
term. For example, you purchase a subscription for 10 users.
| Event | Billable users | Maximum users |
|:---------------------------------------------------|:-----------------|:--------------|
| Ten users occupy all 10 seats. | 10 | 10 |
| Two new users join. | 12 | 12 |
| Three users leave and their accounts are blocked. | 9 | 12 |
| Four new users join. | 13 | 13 |
Users over subscription = 13 - 10 (Maximum users - users in license)
The users over subscription value is always zero for trial license.
If users over subscription value is above zero, then you have more users in your
GitLab instance than you are licensed for. You must pay for the additional users
[before or at the time of renewal](quarterly_reconciliation.md). This is
called the "true up" process. If you do not do this, your license key does not work.
To view the number of users over subscription, go to the **Admin** area.
### View users
View the lists of users in your instance:
1. On the left sidebar, at the bottom, select **Admin**.
1. Select **Users**.
Select a user to view their account information.
#### Check daily and historical billable users
Prerequisites:
- You must be an administrator.
You can get a list of daily and historical billable users in your GitLab instance:
1. [Start a Rails console session](../administration/operations/rails_console.md#starting-a-rails-console-session).
1. Count the number of users in the instance:
```ruby
User.billable.count
```
1. Get the historical maximum number of users on the instance from the past year:
```ruby
::HistoricalData.max_historical_user_count(from: 1.year.ago.beginning_of_day, to: Time.current.end_of_day)
```
#### Update daily and historical billable users
Prerequisites:
- You must be an administrator.
You can trigger a manual update of the daily and historical billable users in your GitLab instance.
1. [Start a Rails console session](../administration/operations/rails_console.md#starting-a-rails-console-session).
1. Force an update of the daily billable users:
```ruby
identifier = Analytics::UsageTrends::Measurement.identifiers[:billable_users]
::Analytics::UsageTrends::CounterJobWorker.new.perform(identifier, User.minimum(:id), User.maximum(:id), Time.zone.now)
```
1. Force an update of the historical max billable users:
```ruby
::HistoricalDataWorker.new.perform
```
### Manage users and subscription seats
Managing the number of users against the number of subscription seats can be difficult:
- If [LDAP is integrated with GitLab](../administration/auth/ldap/_index.md), anyone
in the configured domain can sign up for a GitLab account. This can result in
an unexpected bill at time of renewal.
- If sign-up is turned on in your instance, anyone who can access the instance can
sign up for an account.
GitLab has several features to help you manage the number of users. You can:
- [Require administrator approval for new sign ups](../administration/settings/sign_up_restrictions.md#require-administrator-approval-for-new-sign-ups).
- Automatically block new users, either through
[LDAP](../administration/auth/ldap/_index.md#basic-configuration-settings) or
[OmniAuth](../integration/omniauth.md#configure-common-settings).
- [Limit the number of billable users](../administration/settings/sign_up_restrictions.md#user-cap)
who can sign up or be added to a subscription without administrator approval.
- [Disable new sign-ups](../administration/settings/sign_up_restrictions.md),
and instead manage new users manually.
- View a breakdown of users by role in the
[Users statistics](../administration/admin_area.md#users-statistics) page.
To increase the number of users covered by your license, [buy more seats](#buy-more-seats)
during the subscription period. The cost of seats added during the subscription
period is prorated from the date of purchase through to the end of the subscription
period. You can continue to add users even if you reach the number of users in
license count. GitLab [bills you for the overage](quarterly_reconciliation.md).
If your subscription was activated with an activation code, the additional seats are reflected in
your instance immediately. If you're using a license file, you receive an updated file.
To add the seats, [add the license file](../administration/license_file.md)
to your instance.
### Export license usage
Prerequisites:
- You must be an administrator.
You can export your license usage into a CSV file.
This file contains the information GitLab uses to manually process
[quarterly reconciliations](quarterly_reconciliation.md)
and [renewals](manage_subscription.md#renew-subscription). If your instance is firewalled or an
offline environment, you must provide GitLab with this information.
{{< alert type="warning" >}}
Do not open the license usage file. If you open the file, failures might occur when [you submit your license usage data](../administration/license_file.md#submit-license-usage-data).
{{< /alert >}}
1. On the left sidebar, at the bottom, select **Admin**.
1. Select **Subscription**.
1. In the upper-right corner, select **Export license usage file**.
#### License usage file contents
The license usage file includes the following information:
- License key
- Licensee email
- License start date (UTC)
- License end date (UTC)
- Company
- Timestamp the file was generated at and exported (UTC)
- Table of historical user counts for each day in the period:
- Timestamp the count was recorded (UTC)
- Billable user count
{{< alert type="note" >}}
A custom format is used for [dates](https://gitlab.com/gitlab-org/gitlab/blob/3be39f19ac3412c089be28553e6f91b681e5d739/config/initializers/date_time_formats.rb#L7) and [times](https://gitlab.com/gitlab-org/gitlab/blob/3be39f19ac3412c089be28553e6f91b681e5d739/config/initializers/date_time_formats.rb#L13) in CSV files.
{{< /alert >}}
## GitLab.com billing and usage
{{< details >}}
- Offering: GitLab.com
{{< /details >}}
A GitLab.com subscription uses a concurrent (_seat_) model.
You pay for a subscription according to the maximum number of users assigned to the top-level group,
its subgroups and projects during the billing period.
You can add and remove users during the subscription period without incurring additional charges,
as long as the total users at any given time doesn't exceed the subscription count.
If the total users exceeds your subscription count, you will incur an overage,
which must be paid at your next [reconciliation](quarterly_reconciliation.md).
A top-level group can be [changed](../user/group/manage.md#change-a-groups-path) like any other group.
### Seats owed
If the number of billable users exceeds the number of **seats in subscription**, known
as the number of **seats owed**, you must pay for the excess number of users.
For example, if you purchase a subscription for 10 users:
| Event | Billable members | Maximum users |
|:---------------------------------------------------|:-----------------|:--------------|
| Ten users occupy all 10 seats. | 10 | 10 |
| Two new users join. | 12 | 12 |
| Three users leave and their accounts are removed. | 9 | 12 |
Seats owed = 12 - 10 (Maximum users - users in subscription)
To prevent charges from seats owed, you can
[turn on restricted access](../user/group/manage.md#turn-on-restricted-access).
This setting restricts groups from adding new billable users when there are no seats left in the subscription.
### Seat usage alerts
{{< history >}}
- [Introduced](https://gitlab.com/gitlab-org/gitlab/-/issues/348481) in GitLab 15.2 [with a flag](../administration/feature_flags/_index.md) named `seat_flag_alerts`.
- [Generally available](https://gitlab.com/gitlab-org/gitlab/-/issues/362041) in GitLab 15.4. Feature flag `seat_flag_alerts` removed.
{{< /history >}}
If you have the Owner role for the top-level group, an alert notifies you
of your total seat usage.
The alert displays on group, subgroup, and project
pages, and only for top-level groups linked to subscriptions enrolled
in [quarterly subscription reconciliations](quarterly_reconciliation.md).
After you dismiss the alert, it doesn't display until another seat is used.
The alert displays based on the following seat usage. You cannot configure the
amounts at which the alert displays.
| Seats in subscription | Alert displays when |
|-----------------------|---------------------|
| 0-15 | One seat remains. |
| 16-25 | Two seats remain. |
| 26-99 | 10% of seats remain.|
| 100-999 | 8% of seats remain. |
| 1000+ | 5% of seats remain. |
### View seat usage
To view a list of seats being used:
1. On the left sidebar, select **Search or go to** and find your group.
1. Select **Settings > Usage quotas**.
1. Select the **Seats** tab.
For each user, a list shows groups and projects where the user is a direct member.
- **Group invite** indicates the user is a member of a [group invited to a group](../user/project/members/sharing_projects_groups.md#invite-a-group-to-a-group).
- **Project invite** indicates the user is a member of a [group invited to a project](../user/project/members/sharing_projects_groups.md#invite-a-group-to-a-project).
The data in seat usage listing, **Seats in use**, and **Seats in subscription** are updated live.
The counts for **Max seats used** and **Seats owed** are updated once per day.
#### View billing information
To view your subscription information and a summary of seat counts:
1. On the left sidebar, select **Search or go to** and find your group.
1. Select **Settings > Billing**.
- The usage statistics are updated once per day, which may cause a difference between the information
in the **Usage quotas** page and the **Billing page**.
- The **Last login** field is updated when a user signs in after they have signed out. If there is an active session
when a user re-authenticates (for example, after a 24 hour SAML session timeout), this field is not updated.
### Search seat usage
To search seat usage:
1. On the left sidebar, select **Search or go to** and find your group.
1. Select **Settings > Usage quotas**.
1. On the **Seats** tab, enter a string in the search field. A minimum of 3 characters are required.
The search returns users whose first name, last name, or username contain the search string.
For example:
| First name | Search string | Match ? |
|:-----------|:--------------|:--------|
| Amir | `ami` | Yes |
| Amir | `amr` | No |
### Export seat usage
To export seat usage data as a CSV file:
1. On the left sidebar, select **Search or go to** and find your group.
1. Select **Settings > Usage quotas**.
1. In the **Seats** tab, select **Export list**.
### Export seat usage history
Prerequisites:
- You must have the Owner role for the group.
To export seat usage history as a CSV file:
1. On the left sidebar, select **Search or go to** and find your group.
1. Select **Settings > Usage quotas**.
1. In the **Seats** tab, select **Export seat usage history**.
The generated list contains all seats being used,
and is not affected by the current search.
### Remove users from subscription
To remove a billable user from your GitLab.com subscription:
1. On the left sidebar, select **Search or go to** and find your group.
1. Select **Settings > Billing**.
1. In the **Seats currently in use** section, select **See usage**.
1. In the row for the user you want to remove, on the right side, select **Remove user**.
1. Re-type the username and select **Remove user**.
If you add a member to a group by using the [share a group with another group](../user/project/members/sharing_projects_groups.md#invite-a-group-to-a-group) feature, you can't remove the member by using this method. Instead, you can either:
- [Remove the member from the shared group](../user/group/_index.md#remove-a-member-from-the-group).
- [Remove the invited group](../user/project/members/sharing_projects_groups.md#remove-an-invited-group).
|
https://docs.gitlab.com/choosing_subscription
|
https://gitlab.com/gitlab-org/gitlab/-/tree/master/doc/choosing_subscription.md
|
2025-08-13
|
doc/subscriptions
|
[
"doc",
"subscriptions"
] |
choosing_subscription.md
|
Fulfillment
|
Subscription Management
|
To determine the technical writer assigned to the Stage/Group associated with this page, see https://handbook.gitlab.com/handbook/product/ux/technical-writing/#assignments
|
GitLab plans
|
Options for accessing GitLab.
|
To choose the right GitLab subscription, select an offering and a tier.
## Choose an offering
Choose which GitLab offering suits your needs:
- GitLab.com: The GitLab software-as-a-service offering.
You don't need to install anything to use GitLab.com, you only need to
[sign up](https://gitlab.com/users/sign_up) and start using GitLab straight away.
- [GitLab Dedicated](gitlab_dedicated/_index.md): A single-tenant SaaS service for highly regulated and large enterprises.
- GitLab Self-Managed: Install, administer, and maintain your own GitLab instance.
On GitLab Self-Managed, a GitLab subscription provides the same set of
features for all users.
On GitLab.com, you can apply a subscription to a top-level group
namespace. You cannot apply a subscription to a personal namespace.
{{< alert type="note" >}}
Subscriptions cannot be transferred between GitLab.com and GitLab Self-Managed.
A new subscription must be purchased and applied as needed.
{{< /alert >}}
## Choose a subscription tier
Pricing is [tier-based](https://about.gitlab.com/pricing/), allowing you to choose
the features that fit your budget.
For more details, see [a comparison of features available in each tier](https://about.gitlab.com/pricing/feature-comparison/).
## Choose a subscription add-on
An add-on is an additional paid feature or service that you can purchase on top of an existing
GitLab subscription. Add-ons provide extra functionality or resources to enhance your GitLab
experience.
You can purchase the following add-ons:
- [GitLab Duo](subscription-add-ons.md): Get access to AI-native features like Code Suggestions, GitLab
Duo Chat, and more.
- [Enterprise Agile Planning](manage_subscription.md#enterprise-agile-planning): Increase collaboration between
technical and non-technical teams on a single platform. Non-engineering team members can participate in planning,
measure impact with Value Stream Analytics, and gain visibility into software development velocity.
- [Storage](../user/storage_usage_quotas.md#purchase-more-storage): Buy more storage when you exceed your
free 10 GiB storage quota.
- [Compute minutes](gitlab_com/compute_minutes.md): Buy additional compute minutes when your
plan exceeds its allocated amount and you need to continue running automated
builds, tests, and deployments without interruption.
Some add-ons are only available to specific subscription tiers and offerings.
## Contact Support
- See the tiers of [GitLab Support](https://about.gitlab.com/support/).
- [Submit a request](https://support.gitlab.com/hc/en-us/requests/new) through the Support Portal.
We also encourage all users to search our project trackers for known issues and existing feature requests in the [GitLab project](https://gitlab.com/gitlab-org/gitlab/-/issues/).
These issues are the best avenue for getting updates on specific product plans and for communicating directly with the relevant GitLab team members.
|
---
stage: Fulfillment
group: Subscription Management
info: To determine the technical writer assigned to the Stage/Group associated with
this page, see https://handbook.gitlab.com/handbook/product/ux/technical-writing/#assignments
description: Options for accessing GitLab.
title: GitLab plans
breadcrumbs:
- doc
- subscriptions
---
To choose the right GitLab subscription, select an offering and a tier.
## Choose an offering
Choose which GitLab offering suits your needs:
- GitLab.com: The GitLab software-as-a-service offering.
You don't need to install anything to use GitLab.com, you only need to
[sign up](https://gitlab.com/users/sign_up) and start using GitLab straight away.
- [GitLab Dedicated](gitlab_dedicated/_index.md): A single-tenant SaaS service for highly regulated and large enterprises.
- GitLab Self-Managed: Install, administer, and maintain your own GitLab instance.
On GitLab Self-Managed, a GitLab subscription provides the same set of
features for all users.
On GitLab.com, you can apply a subscription to a top-level group
namespace. You cannot apply a subscription to a personal namespace.
{{< alert type="note" >}}
Subscriptions cannot be transferred between GitLab.com and GitLab Self-Managed.
A new subscription must be purchased and applied as needed.
{{< /alert >}}
## Choose a subscription tier
Pricing is [tier-based](https://about.gitlab.com/pricing/), allowing you to choose
the features that fit your budget.
For more details, see [a comparison of features available in each tier](https://about.gitlab.com/pricing/feature-comparison/).
## Choose a subscription add-on
An add-on is an additional paid feature or service that you can purchase on top of an existing
GitLab subscription. Add-ons provide extra functionality or resources to enhance your GitLab
experience.
You can purchase the following add-ons:
- [GitLab Duo](subscription-add-ons.md): Get access to AI-native features like Code Suggestions, GitLab
Duo Chat, and more.
- [Enterprise Agile Planning](manage_subscription.md#enterprise-agile-planning): Increase collaboration between
technical and non-technical teams on a single platform. Non-engineering team members can participate in planning,
measure impact with Value Stream Analytics, and gain visibility into software development velocity.
- [Storage](../user/storage_usage_quotas.md#purchase-more-storage): Buy more storage when you exceed your
free 10 GiB storage quota.
- [Compute minutes](gitlab_com/compute_minutes.md): Buy additional compute minutes when your
plan exceeds its allocated amount and you need to continue running automated
builds, tests, and deployments without interruption.
Some add-ons are only available to specific subscription tiers and offerings.
## Contact Support
- See the tiers of [GitLab Support](https://about.gitlab.com/support/).
- [Submit a request](https://support.gitlab.com/hc/en-us/requests/new) through the Support Portal.
We also encourage all users to search our project trackers for known issues and existing feature requests in the [GitLab project](https://gitlab.com/gitlab-org/gitlab/-/issues/).
These issues are the best avenue for getting updates on specific product plans and for communicating directly with the relevant GitLab team members.
|
https://docs.gitlab.com/community_programs
|
https://gitlab.com/gitlab-org/gitlab/-/tree/master/doc/community_programs.md
|
2025-08-13
|
doc/subscriptions
|
[
"doc",
"subscriptions"
] |
community_programs.md
|
none
|
unassigned
|
For help with this Community Programs page, see https://handbook.gitlab.com/handbook/marketing/developer-relations/community-programs/
|
Community programs
|
Education, Open Source, Startups.
|
GitLab provides the following community program subscriptions.
## GitLab for Education
For qualifying non-profit educational institutions, the [GitLab for Education Program](https://about.gitlab.com/solutions/education/) provides GitLab Ultimate, plus 50,000 compute minutes per month. The subscription granted under GitLab for Education can only be used for instructional use or non-commercial academic research. For more information, including instructions for applying to the program and renewing program membership, see the [GitLab for Education Program page](https://about.gitlab.com/solutions/education/) and the GitLab handbook.
## GitLab for Open Source
For qualifying open source projects, the [GitLab for Open Source Program](https://about.gitlab.com/solutions/open-source/) provides GitLab Ultimate, plus 50,000 compute minutes per month. For more information, including instructions for applying to the program and renewing program membership, see the [GitLab for Open Source Program page](https://about.gitlab.com/solutions/open-source/) and the GitLab handbook.
### Meeting GitLab for Open Source Program requirements
To meet GitLab for Open Source Program requirements, first add an OSI-approved open source license to all projects in your namespace.
To add a license to a project:
1. On the left sidebar, select **Search or go to** and find your project.
1. On the overview page, select **Add LICENSE**. If the license you want is not available as a license template, manually copy the entire, unaltered [text of your chosen license](https://opensource.org/license) into the `LICENSE` file. GitLab defaults to **All rights reserved** if users do not perform this action.
Applicants must add the correct license to each project in their respective groups or namespaces. When you're sure you're using OSI-approved licenses for your projects, you can take your screenshots.
{{< alert type="note" >}}
GitLab for Open Source Program benefits apply to an entire GitLab namespace. To qualify for the GitLab for Open Source Program, all projects in your namespace must meet program requirements.
{{< /alert >}}
### Verification for Open Source Program
The verification process depends on where your projects are hosted:
- For projects on GitLab.com, verification is automatic.
- For projects on GitLab Self-Managed, when you submit your request, you must provide a link to the publicly accessible namespace that contains the projects.
GitLab verifies three aspects of your namespace:
- The namespace must be publicly accessible.
- Each project in the namespace must use an [OSI-approved license](https://opensource.org/licenses).
- Projects in the namespace must be publicly visible, except one private project is allowed for security purposes.
{{< alert type="note" >}}
Benefits of the GitLab Open Source Program apply to all projects in a GitLab namespace. All projects in an eligible namespace must meet program requirements.
{{< /alert >}}
## GitLab for Startups
For qualifying startups, the [GitLab for Startups](https://about.gitlab.com/solutions/startups/) program provides GitLab Ultimate, plus 50,000 compute minutes per month for 12 months. For more information, including instructions for applying to the program and renewing program membership, see the [GitLab for Startups Program page](https://about.gitlab.com/solutions/startups/) and the GitLab handbook.
|
---
stage: none
group: unassigned
info: For help with this Community Programs page, see https://handbook.gitlab.com/handbook/marketing/developer-relations/community-programs/
description: Education, Open Source, Startups.
title: Community programs
breadcrumbs:
- doc
- subscriptions
---
GitLab provides the following community program subscriptions.
## GitLab for Education
For qualifying non-profit educational institutions, the [GitLab for Education Program](https://about.gitlab.com/solutions/education/) provides GitLab Ultimate, plus 50,000 compute minutes per month. The subscription granted under GitLab for Education can only be used for instructional use or non-commercial academic research. For more information, including instructions for applying to the program and renewing program membership, see the [GitLab for Education Program page](https://about.gitlab.com/solutions/education/) and the GitLab handbook.
## GitLab for Open Source
For qualifying open source projects, the [GitLab for Open Source Program](https://about.gitlab.com/solutions/open-source/) provides GitLab Ultimate, plus 50,000 compute minutes per month. For more information, including instructions for applying to the program and renewing program membership, see the [GitLab for Open Source Program page](https://about.gitlab.com/solutions/open-source/) and the GitLab handbook.
### Meeting GitLab for Open Source Program requirements
To meet GitLab for Open Source Program requirements, first add an OSI-approved open source license to all projects in your namespace.
To add a license to a project:
1. On the left sidebar, select **Search or go to** and find your project.
1. On the overview page, select **Add LICENSE**. If the license you want is not available as a license template, manually copy the entire, unaltered [text of your chosen license](https://opensource.org/license) into the `LICENSE` file. GitLab defaults to **All rights reserved** if users do not perform this action.
Applicants must add the correct license to each project in their respective groups or namespaces. When you're sure you're using OSI-approved licenses for your projects, you can take your screenshots.
{{< alert type="note" >}}
GitLab for Open Source Program benefits apply to an entire GitLab namespace. To qualify for the GitLab for Open Source Program, all projects in your namespace must meet program requirements.
{{< /alert >}}
### Verification for Open Source Program
The verification process depends on where your projects are hosted:
- For projects on GitLab.com, verification is automatic.
- For projects on GitLab Self-Managed, when you submit your request, you must provide a link to the publicly accessible namespace that contains the projects.
GitLab verifies three aspects of your namespace:
- The namespace must be publicly accessible.
- Each project in the namespace must use an [OSI-approved license](https://opensource.org/licenses).
- Projects in the namespace must be publicly visible, except one private project is allowed for security purposes.
{{< alert type="note" >}}
Benefits of the GitLab Open Source Program apply to all projects in a GitLab namespace. All projects in an eligible namespace must meet program requirements.
{{< /alert >}}
## GitLab for Startups
For qualifying startups, the [GitLab for Startups](https://about.gitlab.com/solutions/startups/) program provides GitLab Ultimate, plus 50,000 compute minutes per month for 12 months. For more information, including instructions for applying to the program and renewing program membership, see the [GitLab for Startups Program page](https://about.gitlab.com/solutions/startups/) and the GitLab handbook.
|
https://docs.gitlab.com/subscriptions/gitlab_dedicated
|
https://gitlab.com/gitlab-org/gitlab/-/tree/master/doc/subscriptions/_index.md
|
2025-08-13
|
doc/subscriptions/gitlab_dedicated
|
[
"doc",
"subscriptions",
"gitlab_dedicated"
] |
_index.md
|
GitLab Dedicated
|
Switchboard
|
To determine the technical writer assigned to the Stage/Group associated with this page, see https://handbook.gitlab.com/handbook/product/ux/technical-writing/#assignments
|
GitLab Dedicated
|
Available features and benefits.
|
{{< details >}}
- Tier: Ultimate
- Offering: GitLab Dedicated
{{< /details >}}
GitLab Dedicated is a single-tenant SaaS solution that is:
- Fully isolated.
- Deployed in your preferred AWS cloud region.
- Hosted and maintained by GitLab.
Each instance provides:
- [High availability](data_residency_and_high_availability.md) with disaster recovery.
- [Regular updates](maintenance.md) with the latest features.
- Enterprise-grade security measures.
With GitLab Dedicated, you can:
- Increase operational efficiency.
- Reduce infrastructure management overhead.
- Improve organizational agility.
- Meet strict compliance requirements.
## Available features
This section lists the key features that are available for GitLab Dedicated.
### Security
GitLab Dedicated provides the following security features to protect your data and control access to your instance.
#### Authentication and authorization
GitLab Dedicated supports [SAML](../../administration/dedicated/configure_instance/saml.md) and [OpenID Connect (OIDC)](../../administration/dedicated/configure_instance/openid_connect.md) providers for single sign-on (SSO).
You can configure single sign-on (SSO) using the supported providers for authentication. Your instance acts as the service provider, and you provide the necessary configuration for GitLab to communicate with your Identity Providers (IdPs).
#### Secure networking
Two connectivity options are available:
- Public connectivity with IP allowlists: By default, your instance is publicly accessible. You can [configure an IP allowlist](../../administration/dedicated/configure_instance/network_security.md#ip-allowlist) to restrict access to specified IP addresses.
- Private connectivity with AWS PrivateLink: You can configure [AWS PrivateLink](https://aws.amazon.com/privatelink/) for [inbound](../../administration/dedicated/configure_instance/network_security.md#inbound-private-link) and [outbound](../../administration/dedicated/configure_instance/network_security.md#outbound-private-link) connections.
For private connections to internal resources using non-public certificates, you can also [specify trusted certificates](../../administration/dedicated/configure_instance/network_security.md#custom-certificates).
#### Data encryption
Data is encrypted at rest and in transit using the latest encryption standards.
Optionally, you can use your own AWS Key Management Service (KMS) encryption key for data at rest. This option gives you full control over the data you store in GitLab.
For more information, see [encrypted data at rest (BYOK)](../../administration/dedicated/encryption.md#encrypted-data-at-rest).
#### Email service
By default, [Amazon Simple Email Service (Amazon SES)](https://aws.amazon.com/ses/) is used to send emails securely. As an alternative, you can [configure your own email service](../../administration/dedicated/configure_instance/users_notifications.md#smtp-email-service) using SMTP.
### Compliance
GitLab Dedicated adheres to various regulations, certifications, and compliance frameworks to ensure the security, and reliability of your data.
#### View compliance and certification details
You can view compliance and certification details, and download compliance artifacts from the [GitLab Dedicated Trust Center](https://trust.gitlab.com/?product=gitlab-dedicated).
#### Access controls
GitLab Dedicated implements strict access controls to protect your environment:
- Follows the principle of least privilege, which grants only the minimum permissions necessary.
- Restricts access to the AWS organization to select GitLab team members.
- Implements comprehensive security policies and access requests for user accounts.
- Uses a single Hub account for automated actions and emergency access.
- GitLab Dedicated engineers do not have direct access to customer environments.
In [emergency situations](https://gitlab.com/gitlab-com/gl-infra/gitlab-dedicated/incident-management/-/blob/main/procedures/break-glass.md#break-glass-procedure), GitLab engineers must:
1. Use the Hub account to access customer resources.
1. Request access through an approval process.
1. Assume a temporary IAM role through the Hub account.
All actions in the Hub and tenant accounts are logged to CloudTrail.
#### Monitoring
In tenant accounts, GitLab Dedicated uses:
- AWS GuardDuty for intrusion detection and malware scanning.
- Infrastructure log monitoring by the GitLab Security Incident Response Team to detect anomalous events.
#### Audit and observability
You can access [application logs](../../administration/dedicated/monitor.md) for auditing and observability purposes. These logs provide insights into system activities and user actions, helping you monitor your instance and maintain compliance requirements.
### Bring your own domain
You can use your own hostname to access your GitLab Dedicated instance. Instead of `tenant_name.gitlab-dedicated.com`, you can use a hostname for a domain that you own, like `gitlab.my-company.com`. Optionally, you can also provide a custom hostname for the bundled container registry and KAS services for your GitLab Dedicated instance. For example, `gitlab-registry.my-company.com` and `gitlab-kas.my-company.com`.
Add a custom hostname to:
- Increase control over branding
- Avoid having to migrate away from an existing domain already configured for a GitLab Self-Managed instance
When you add a custom hostname:
- The hostname is included in the external URL used to access your instance.
- Any connections to your instance using the previous domain names are no longer available.
For more information about using a custom hostname for your GitLab Dedicated instance, see [bring your own domain (BYOD)](../../administration/dedicated/configure_instance/network_security.md#bring-your-own-domain-byod).
{{< alert type="note" >}}
Custom hostnames for GitLab Pages are not supported. If you use GitLab Pages, the URL to access the Pages site for your GitLab Dedicated instance would be `tenant_name.gitlab-dedicated.site`.
{{< /alert >}}
### Application
GitLab Dedicated comes with the self-managed [Ultimate feature set](https://about.gitlab.com/pricing/feature-comparison/) with a small number of exceptions. For more information, see [Unavailable features](#unavailable-features).
#### Advanced search
GitLab Dedicated uses the [advanced search functionality](../../integration/advanced_search/elasticsearch.md).
#### ClickHouse
You can access [advanced analytical features](../../integration/clickhouse.md) through the ClickHouse integration,
which is enabled by default for eligible customers. You are eligible if:
- Your GitLab Dedicated tenant is deployed to a commercial AWS region. GitLab Dedicated for Government is not supported.
- Your tenant's primary region is supported by ClickHouse Cloud. For a list of supported regions, see [supported regions for ClickHouse Cloud](https://clickhouse.com/docs/cloud/reference/supported-regions#aws-regions).
ClickHouse serves as a secondary data store for your GitLab Dedicated instance, enabling advanced analytics capabilities.
Your GitLab Dedicated instance includes a ClickHouse Cloud database deployed in your tenant's primary region.
The database is not publicly accessible and connects through AWS PrivateLink.
Your data is encrypted in transit and at rest using cloud provider-managed AES 256 keys and transparent data encryption.
The ClickHouse endpoint address is automatically added to the allowlist when you have configured your GitLab Dedicated instance to [filter outbound requests](../../security/webhooks.md#allow-outbound-requests-to-certain-ip-addresses-and-domains).
ClickHouse on GitLab Dedicated has the following limitations:
- [Bring your own key (BYOK)](../../administration/dedicated/encryption.md#bring-your-own-key-byok) is not supported.
- No SLAs apply. Recovery Time Objective (RTO) and Recovery Point Objective (RPO) are best efforts.
#### GitLab Pages
You can use [GitLab Pages](../../user/project/pages/_index.md) on GitLab Dedicated to host your static website. The domain name is `tenant_name.gitlab-dedicated.site`, where `tenant_name` is the same as your instance URL.
{{< alert type="note" >}}
Custom domains for GitLab Pages are not supported. For example, if you added a custom domain named `gitlab.my-company.com`, the URL to access the Pages site for your GitLab Dedicated instance would still be `tenant_name.gitlab-dedicated.site`.
{{< /alert >}}
You can control access to your Pages website with:
- [GitLab Pages access control](../../user/project/pages/pages_access_control.md).
- [IP allowlists](../../administration/dedicated/configure_instance/network_security.md#ip-allowlist). Any existing IP allowlists for your GitLab Dedicated instances are applied.
GitLab Pages for Dedicated:
- Is enabled by default.
- Only works in the primary site if [Geo](../../administration/geo/_index.md) is enabled.
- Is not included as part of instance migrations to GitLab Dedicated.
#### Hosted runners
[Hosted runners for GitLab Dedicated](../../administration/dedicated/hosted_runners.md) allow you to scale CI/CD workloads with no maintenance overhead.
#### Self-managed runners
As an alternative to using hosted runners, you can use your own runners for your GitLab Dedicated instance.
To use self-managed runners, install [GitLab Runner](https://docs.gitlab.com/runner/install/) on infrastructure that you own or manage.
#### OpenID Connect and SCIM
You can use [SCIM for user management](../../api/scim.md) or [GitLab as an OpenID Connect identity provider](../../integration/openid_connect_provider.md) while maintaining IP restrictions to your instance.
To use these features with IP allowlists:
- [Enable SCIM provisioning for your IP allowlist](../../administration/dedicated/configure_instance/network_security.md#enable-scim-provisioning-for-your-ip-allowlist)
- [Enable OpenID Connect for your IP allowlist](../../administration/dedicated/configure_instance/network_security.md#enable-openid-connect-for-your-ip-allowlist)
### Pre-production environments
GitLab Dedicated supports pre-production environments that match the configuration of production environments. You can use pre-production environments to:
- Test new features before implementing them in production.
- Test configuration changes before applying them in production.
Pre-production environments must be purchased as an add-on to your GitLab Dedicated subscription, with no additional licenses required.
The following capabilities are available:
- Flexible sizing: Match the size of your production environment or use a smaller reference architecture.
- Version consistency: Runs the same GitLab version as your production environment.
Limitations:
- Single-region deployment only.
- No SLA commitment.
- Cannot run newer versions than production.
## Unavailable features
This section lists the features that are not available for GitLab Dedicated.
### Authentication, security, and networking
| Feature | Description | Impact |
| --------------------------------------------- | --------------------------------------------------------------------- | -------------------------------------------------------------- |
| LDAP authentication | Authentication using corporate LDAP/Active Directory credentials. | Must use GitLab-specific passwords or access tokens instead. |
| Smart card authentication | Authentication using smart cards for enhanced security. | Cannot use existing smart card infrastructure. |
| Kerberos authentication | Single sign-on authentication using Kerberos protocol. | Must authenticate separately to GitLab. |
| Multiple login providers | Configuration of multiple OAuth/SAML providers (Google, GitHub). | Limited to a single identity provider. |
| FortiAuthenticator/FortiToken 2FA | Two-factor authentication using Fortinet security solutions. | Cannot integrate existing Fortinet 2FA infrastructure. |
| Git clone using HTTPS with username/password | Git operations using username and password authentication over HTTPS. | Must use access tokens for Git operations. |
| [Sigstore](../../ci/yaml/signing_examples.md) | Keyless signing and verification for software supply chain security. | Must use traditional code signing methods. |
| Port remapping | Remap ports like SSH (22) to different inbound ports. | GitLab Dedicated only uses default communication ports. |
### Communication and collaboration
| Feature | Description | Impact |
| -------------- | ------------------------------------------------------------------- | ---------------------------------------------------------- |
| Reply by email | Respond to GitLab notifications and discussions through email. | Must use GitLab web interface to respond. |
| Service Desk | Ticketing system for external users to create issues through email. | External users must have GitLab accounts to create issues. |
### Development and AI features
| Feature | Description | Impact |
| -------------------------------------- | ------------------------------------------------------------------------------------ | -------------------------------------------- |
| Some GitLab Duo AI capabilities | AI-powered features for code suggestions, vulnerability detection, and productivity. | Limited AI assistance for development tasks. |
| Features behind disabled feature flags | Experimental or unreleased features disabled by default. | Cannot access features in development. |
For more information about AI features, see [GitLab Duo](../../user/gitlab_duo/_index.md).
#### Feature flags
GitLab uses [feature flags](../../administration/feature_flags/_index.md) to support the
development and rollout of new or experimental features. In GitLab Dedicated:
- Features behind feature flags that are enabled by default are available.
- Features behind feature flags that are disabled by default are not available and
cannot be enabled by administrators.
Features behind flags that are disabled by default are not ready for production use and
therefore unsafe for GitLab Dedicated.
When a feature becomes generally available and the flag is enabled or removed, the feature
becomes available in GitLab Dedicated in the same GitLab version. GitLab Dedicated follows
its own [release schedule](maintenance.md) for version deployments.
### GitLab Pages
| Feature | Description | Impact |
| ---------------------------- | --------------------------------------------------------------- | ---------------------------------------------------------------------- |
| Custom domains | Host GitLab Pages sites on custom domain names. | Pages sites accessible only using `tenant_name.gitlab-dedicated.site`. |
| PrivateLink access | Private network access to GitLab Pages through AWS PrivateLink. | Pages sites must be accessed over public internet. |
| Namespaces in URL path | Organize Pages sites with namespace-based URL structure. | Limited URL organization options. |
| Let's Encrypt integration | Automatic SSL certificate provisioning for Pages sites. | Must manage SSL certificates manually. |
| Reduced authentication scope | Fine-grained access controls for Pages sites. | Less flexible authentication options. |
| Running Pages behind a proxy | Deploy Pages sites behind reverse proxy configurations. | Limited deployment architecture options. |
### Operational features
The following operational features are not available:
- Multiple Geo secondaries (Geo replicas) beyond the secondary site included by default
- [Geo proxying](../../administration/geo/secondary_proxy/_index.md) and using a unified URL
- Self-serve purchasing and configuration
- Support for deploying to non-AWS cloud providers, such as GCP or Azure
- Observability dashboard in Switchboard
### Features that require server access
The following features require direct server access and cannot be configured:
| Feature | Description | Impact |
| ------------------------------------------------------------- | ------------------------------------------------------------------ | ------------------------------------------------------------------------------------------------------------------------- |
| [Mattermost](../../integration/mattermost/_index.md) | Integrated team chat and collaboration platform. | Use external chat solutions. |
| [Server-side Git hooks](../../administration/server_hooks.md) | Custom scripts that run on Git events (pre-receive, post-receive). | Use [push rules](../../user/project/repository/push_rules.md) or [webhooks](../../user/project/integrations/webhooks.md). |
{{< alert type="note" >}}
Access to the underlying infrastructure is only available to GitLab team members.
Due to the server-side configuration, there is a security concern with running arbitrary code on services,
and the possible impact on the service SLA. As an alternative, use [push rules](../../user/project/repository/push_rules.md)
or [webhooks](../../user/project/integrations/webhooks.md) instead.
{{< /alert >}}
## Service level availability
GitLab Dedicated maintains a monthly service level objective of 99.5% availability.
Service level availability measures the percentage of time that GitLab Dedicated is available for use during a calendar month. GitLab calculates availability based on the following core services:
| Service area | Included features |
| ------------------ | --------------------------------------------------------------------------------- |
| Web interface | GitLab issues, merge requests, CI job logs, GitLab API, Git operations over HTTPS |
| Container Registry | Registry HTTPS requests |
| Git operations | Git push, pull, and clone operations over SSH |
### Service level exclusions
The following are not included in service level availability calculations:
- Service interruptions caused by customer misconfigurations
- Issues with customer or cloud provider infrastructure outside of GitLab control
- Scheduled maintenance windows
- Emergency maintenance for critical security or data issues
- Service disruptions caused by natural disasters, widespread internet outages, datacenter failures, or other events outside of GitLab control.
## Migrate to GitLab Dedicated
To migrate your data to GitLab Dedicated:
- From another GitLab instance:
- Use [direct transfer](../../user/group/import/_index.md).
- Use the [direct transfer API](../../api/bulk_imports.md).
- From third-party services:
- Use [the import sources](../../user/project/import/_index.md#supported-import-sources).
- For complex migrations:
- Engage [Professional Services](../../user/project/import/_index.md#migrate-by-engaging-professional-services).
## Get started
For more information about GitLab Dedicated or to request a demo, see [GitLab Dedicated](https://about.gitlab.com/dedicated/).
For more information on setting up your GitLab Dedicated instance, see [Create your GitLab Dedicated instance](../../administration/dedicated/create_instance/_index.md).
|
---
stage: GitLab Dedicated
group: Switchboard
info: To determine the technical writer assigned to the Stage/Group associated with
this page, see https://handbook.gitlab.com/handbook/product/ux/technical-writing/#assignments
description: Available features and benefits.
title: GitLab Dedicated
breadcrumbs:
- doc
- subscriptions
- gitlab_dedicated
---
{{< details >}}
- Tier: Ultimate
- Offering: GitLab Dedicated
{{< /details >}}
GitLab Dedicated is a single-tenant SaaS solution that is:
- Fully isolated.
- Deployed in your preferred AWS cloud region.
- Hosted and maintained by GitLab.
Each instance provides:
- [High availability](data_residency_and_high_availability.md) with disaster recovery.
- [Regular updates](maintenance.md) with the latest features.
- Enterprise-grade security measures.
With GitLab Dedicated, you can:
- Increase operational efficiency.
- Reduce infrastructure management overhead.
- Improve organizational agility.
- Meet strict compliance requirements.
## Available features
This section lists the key features that are available for GitLab Dedicated.
### Security
GitLab Dedicated provides the following security features to protect your data and control access to your instance.
#### Authentication and authorization
GitLab Dedicated supports [SAML](../../administration/dedicated/configure_instance/saml.md) and [OpenID Connect (OIDC)](../../administration/dedicated/configure_instance/openid_connect.md) providers for single sign-on (SSO).
You can configure single sign-on (SSO) using the supported providers for authentication. Your instance acts as the service provider, and you provide the necessary configuration for GitLab to communicate with your Identity Providers (IdPs).
#### Secure networking
Two connectivity options are available:
- Public connectivity with IP allowlists: By default, your instance is publicly accessible. You can [configure an IP allowlist](../../administration/dedicated/configure_instance/network_security.md#ip-allowlist) to restrict access to specified IP addresses.
- Private connectivity with AWS PrivateLink: You can configure [AWS PrivateLink](https://aws.amazon.com/privatelink/) for [inbound](../../administration/dedicated/configure_instance/network_security.md#inbound-private-link) and [outbound](../../administration/dedicated/configure_instance/network_security.md#outbound-private-link) connections.
For private connections to internal resources using non-public certificates, you can also [specify trusted certificates](../../administration/dedicated/configure_instance/network_security.md#custom-certificates).
#### Data encryption
Data is encrypted at rest and in transit using the latest encryption standards.
Optionally, you can use your own AWS Key Management Service (KMS) encryption key for data at rest. This option gives you full control over the data you store in GitLab.
For more information, see [encrypted data at rest (BYOK)](../../administration/dedicated/encryption.md#encrypted-data-at-rest).
#### Email service
By default, [Amazon Simple Email Service (Amazon SES)](https://aws.amazon.com/ses/) is used to send emails securely. As an alternative, you can [configure your own email service](../../administration/dedicated/configure_instance/users_notifications.md#smtp-email-service) using SMTP.
### Compliance
GitLab Dedicated adheres to various regulations, certifications, and compliance frameworks to ensure the security, and reliability of your data.
#### View compliance and certification details
You can view compliance and certification details, and download compliance artifacts from the [GitLab Dedicated Trust Center](https://trust.gitlab.com/?product=gitlab-dedicated).
#### Access controls
GitLab Dedicated implements strict access controls to protect your environment:
- Follows the principle of least privilege, which grants only the minimum permissions necessary.
- Restricts access to the AWS organization to select GitLab team members.
- Implements comprehensive security policies and access requests for user accounts.
- Uses a single Hub account for automated actions and emergency access.
- GitLab Dedicated engineers do not have direct access to customer environments.
In [emergency situations](https://gitlab.com/gitlab-com/gl-infra/gitlab-dedicated/incident-management/-/blob/main/procedures/break-glass.md#break-glass-procedure), GitLab engineers must:
1. Use the Hub account to access customer resources.
1. Request access through an approval process.
1. Assume a temporary IAM role through the Hub account.
All actions in the Hub and tenant accounts are logged to CloudTrail.
#### Monitoring
In tenant accounts, GitLab Dedicated uses:
- AWS GuardDuty for intrusion detection and malware scanning.
- Infrastructure log monitoring by the GitLab Security Incident Response Team to detect anomalous events.
#### Audit and observability
You can access [application logs](../../administration/dedicated/monitor.md) for auditing and observability purposes. These logs provide insights into system activities and user actions, helping you monitor your instance and maintain compliance requirements.
### Bring your own domain
You can use your own hostname to access your GitLab Dedicated instance. Instead of `tenant_name.gitlab-dedicated.com`, you can use a hostname for a domain that you own, like `gitlab.my-company.com`. Optionally, you can also provide a custom hostname for the bundled container registry and KAS services for your GitLab Dedicated instance. For example, `gitlab-registry.my-company.com` and `gitlab-kas.my-company.com`.
Add a custom hostname to:
- Increase control over branding
- Avoid having to migrate away from an existing domain already configured for a GitLab Self-Managed instance
When you add a custom hostname:
- The hostname is included in the external URL used to access your instance.
- Any connections to your instance using the previous domain names are no longer available.
For more information about using a custom hostname for your GitLab Dedicated instance, see [bring your own domain (BYOD)](../../administration/dedicated/configure_instance/network_security.md#bring-your-own-domain-byod).
{{< alert type="note" >}}
Custom hostnames for GitLab Pages are not supported. If you use GitLab Pages, the URL to access the Pages site for your GitLab Dedicated instance would be `tenant_name.gitlab-dedicated.site`.
{{< /alert >}}
### Application
GitLab Dedicated comes with the self-managed [Ultimate feature set](https://about.gitlab.com/pricing/feature-comparison/) with a small number of exceptions. For more information, see [Unavailable features](#unavailable-features).
#### Advanced search
GitLab Dedicated uses the [advanced search functionality](../../integration/advanced_search/elasticsearch.md).
#### ClickHouse
You can access [advanced analytical features](../../integration/clickhouse.md) through the ClickHouse integration,
which is enabled by default for eligible customers. You are eligible if:
- Your GitLab Dedicated tenant is deployed to a commercial AWS region. GitLab Dedicated for Government is not supported.
- Your tenant's primary region is supported by ClickHouse Cloud. For a list of supported regions, see [supported regions for ClickHouse Cloud](https://clickhouse.com/docs/cloud/reference/supported-regions#aws-regions).
ClickHouse serves as a secondary data store for your GitLab Dedicated instance, enabling advanced analytics capabilities.
Your GitLab Dedicated instance includes a ClickHouse Cloud database deployed in your tenant's primary region.
The database is not publicly accessible and connects through AWS PrivateLink.
Your data is encrypted in transit and at rest using cloud provider-managed AES 256 keys and transparent data encryption.
The ClickHouse endpoint address is automatically added to the allowlist when you have configured your GitLab Dedicated instance to [filter outbound requests](../../security/webhooks.md#allow-outbound-requests-to-certain-ip-addresses-and-domains).
ClickHouse on GitLab Dedicated has the following limitations:
- [Bring your own key (BYOK)](../../administration/dedicated/encryption.md#bring-your-own-key-byok) is not supported.
- No SLAs apply. Recovery Time Objective (RTO) and Recovery Point Objective (RPO) are best efforts.
#### GitLab Pages
You can use [GitLab Pages](../../user/project/pages/_index.md) on GitLab Dedicated to host your static website. The domain name is `tenant_name.gitlab-dedicated.site`, where `tenant_name` is the same as your instance URL.
{{< alert type="note" >}}
Custom domains for GitLab Pages are not supported. For example, if you added a custom domain named `gitlab.my-company.com`, the URL to access the Pages site for your GitLab Dedicated instance would still be `tenant_name.gitlab-dedicated.site`.
{{< /alert >}}
You can control access to your Pages website with:
- [GitLab Pages access control](../../user/project/pages/pages_access_control.md).
- [IP allowlists](../../administration/dedicated/configure_instance/network_security.md#ip-allowlist). Any existing IP allowlists for your GitLab Dedicated instances are applied.
GitLab Pages for Dedicated:
- Is enabled by default.
- Only works in the primary site if [Geo](../../administration/geo/_index.md) is enabled.
- Is not included as part of instance migrations to GitLab Dedicated.
#### Hosted runners
[Hosted runners for GitLab Dedicated](../../administration/dedicated/hosted_runners.md) allow you to scale CI/CD workloads with no maintenance overhead.
#### Self-managed runners
As an alternative to using hosted runners, you can use your own runners for your GitLab Dedicated instance.
To use self-managed runners, install [GitLab Runner](https://docs.gitlab.com/runner/install/) on infrastructure that you own or manage.
#### OpenID Connect and SCIM
You can use [SCIM for user management](../../api/scim.md) or [GitLab as an OpenID Connect identity provider](../../integration/openid_connect_provider.md) while maintaining IP restrictions to your instance.
To use these features with IP allowlists:
- [Enable SCIM provisioning for your IP allowlist](../../administration/dedicated/configure_instance/network_security.md#enable-scim-provisioning-for-your-ip-allowlist)
- [Enable OpenID Connect for your IP allowlist](../../administration/dedicated/configure_instance/network_security.md#enable-openid-connect-for-your-ip-allowlist)
### Pre-production environments
GitLab Dedicated supports pre-production environments that match the configuration of production environments. You can use pre-production environments to:
- Test new features before implementing them in production.
- Test configuration changes before applying them in production.
Pre-production environments must be purchased as an add-on to your GitLab Dedicated subscription, with no additional licenses required.
The following capabilities are available:
- Flexible sizing: Match the size of your production environment or use a smaller reference architecture.
- Version consistency: Runs the same GitLab version as your production environment.
Limitations:
- Single-region deployment only.
- No SLA commitment.
- Cannot run newer versions than production.
## Unavailable features
This section lists the features that are not available for GitLab Dedicated.
### Authentication, security, and networking
| Feature | Description | Impact |
| --------------------------------------------- | --------------------------------------------------------------------- | -------------------------------------------------------------- |
| LDAP authentication | Authentication using corporate LDAP/Active Directory credentials. | Must use GitLab-specific passwords or access tokens instead. |
| Smart card authentication | Authentication using smart cards for enhanced security. | Cannot use existing smart card infrastructure. |
| Kerberos authentication | Single sign-on authentication using Kerberos protocol. | Must authenticate separately to GitLab. |
| Multiple login providers | Configuration of multiple OAuth/SAML providers (Google, GitHub). | Limited to a single identity provider. |
| FortiAuthenticator/FortiToken 2FA | Two-factor authentication using Fortinet security solutions. | Cannot integrate existing Fortinet 2FA infrastructure. |
| Git clone using HTTPS with username/password | Git operations using username and password authentication over HTTPS. | Must use access tokens for Git operations. |
| [Sigstore](../../ci/yaml/signing_examples.md) | Keyless signing and verification for software supply chain security. | Must use traditional code signing methods. |
| Port remapping | Remap ports like SSH (22) to different inbound ports. | GitLab Dedicated only uses default communication ports. |
### Communication and collaboration
| Feature | Description | Impact |
| -------------- | ------------------------------------------------------------------- | ---------------------------------------------------------- |
| Reply by email | Respond to GitLab notifications and discussions through email. | Must use GitLab web interface to respond. |
| Service Desk | Ticketing system for external users to create issues through email. | External users must have GitLab accounts to create issues. |
### Development and AI features
| Feature | Description | Impact |
| -------------------------------------- | ------------------------------------------------------------------------------------ | -------------------------------------------- |
| Some GitLab Duo AI capabilities | AI-powered features for code suggestions, vulnerability detection, and productivity. | Limited AI assistance for development tasks. |
| Features behind disabled feature flags | Experimental or unreleased features disabled by default. | Cannot access features in development. |
For more information about AI features, see [GitLab Duo](../../user/gitlab_duo/_index.md).
#### Feature flags
GitLab uses [feature flags](../../administration/feature_flags/_index.md) to support the
development and rollout of new or experimental features. In GitLab Dedicated:
- Features behind feature flags that are enabled by default are available.
- Features behind feature flags that are disabled by default are not available and
cannot be enabled by administrators.
Features behind flags that are disabled by default are not ready for production use and
therefore unsafe for GitLab Dedicated.
When a feature becomes generally available and the flag is enabled or removed, the feature
becomes available in GitLab Dedicated in the same GitLab version. GitLab Dedicated follows
its own [release schedule](maintenance.md) for version deployments.
### GitLab Pages
| Feature | Description | Impact |
| ---------------------------- | --------------------------------------------------------------- | ---------------------------------------------------------------------- |
| Custom domains | Host GitLab Pages sites on custom domain names. | Pages sites accessible only using `tenant_name.gitlab-dedicated.site`. |
| PrivateLink access | Private network access to GitLab Pages through AWS PrivateLink. | Pages sites must be accessed over public internet. |
| Namespaces in URL path | Organize Pages sites with namespace-based URL structure. | Limited URL organization options. |
| Let's Encrypt integration | Automatic SSL certificate provisioning for Pages sites. | Must manage SSL certificates manually. |
| Reduced authentication scope | Fine-grained access controls for Pages sites. | Less flexible authentication options. |
| Running Pages behind a proxy | Deploy Pages sites behind reverse proxy configurations. | Limited deployment architecture options. |
### Operational features
The following operational features are not available:
- Multiple Geo secondaries (Geo replicas) beyond the secondary site included by default
- [Geo proxying](../../administration/geo/secondary_proxy/_index.md) and using a unified URL
- Self-serve purchasing and configuration
- Support for deploying to non-AWS cloud providers, such as GCP or Azure
- Observability dashboard in Switchboard
### Features that require server access
The following features require direct server access and cannot be configured:
| Feature | Description | Impact |
| ------------------------------------------------------------- | ------------------------------------------------------------------ | ------------------------------------------------------------------------------------------------------------------------- |
| [Mattermost](../../integration/mattermost/_index.md) | Integrated team chat and collaboration platform. | Use external chat solutions. |
| [Server-side Git hooks](../../administration/server_hooks.md) | Custom scripts that run on Git events (pre-receive, post-receive). | Use [push rules](../../user/project/repository/push_rules.md) or [webhooks](../../user/project/integrations/webhooks.md). |
{{< alert type="note" >}}
Access to the underlying infrastructure is only available to GitLab team members.
Due to the server-side configuration, there is a security concern with running arbitrary code on services,
and the possible impact on the service SLA. As an alternative, use [push rules](../../user/project/repository/push_rules.md)
or [webhooks](../../user/project/integrations/webhooks.md) instead.
{{< /alert >}}
## Service level availability
GitLab Dedicated maintains a monthly service level objective of 99.5% availability.
Service level availability measures the percentage of time that GitLab Dedicated is available for use during a calendar month. GitLab calculates availability based on the following core services:
| Service area | Included features |
| ------------------ | --------------------------------------------------------------------------------- |
| Web interface | GitLab issues, merge requests, CI job logs, GitLab API, Git operations over HTTPS |
| Container Registry | Registry HTTPS requests |
| Git operations | Git push, pull, and clone operations over SSH |
### Service level exclusions
The following are not included in service level availability calculations:
- Service interruptions caused by customer misconfigurations
- Issues with customer or cloud provider infrastructure outside of GitLab control
- Scheduled maintenance windows
- Emergency maintenance for critical security or data issues
- Service disruptions caused by natural disasters, widespread internet outages, datacenter failures, or other events outside of GitLab control.
## Migrate to GitLab Dedicated
To migrate your data to GitLab Dedicated:
- From another GitLab instance:
- Use [direct transfer](../../user/group/import/_index.md).
- Use the [direct transfer API](../../api/bulk_imports.md).
- From third-party services:
- Use [the import sources](../../user/project/import/_index.md#supported-import-sources).
- For complex migrations:
- Engage [Professional Services](../../user/project/import/_index.md#migrate-by-engaging-professional-services).
## Get started
For more information about GitLab Dedicated or to request a demo, see [GitLab Dedicated](https://about.gitlab.com/dedicated/).
For more information on setting up your GitLab Dedicated instance, see [Create your GitLab Dedicated instance](../../administration/dedicated/create_instance/_index.md).
|
https://docs.gitlab.com/subscriptions/maintenance
|
https://gitlab.com/gitlab-org/gitlab/-/tree/master/doc/subscriptions/maintenance.md
|
2025-08-13
|
doc/subscriptions/gitlab_dedicated
|
[
"doc",
"subscriptions",
"gitlab_dedicated"
] |
maintenance.md
|
GitLab Dedicated
|
Environment Automation
|
To determine the technical writer assigned to the Stage/Group associated with this page, see https://handbook.gitlab.com/handbook/product/ux/technical-writing/#assignments
|
Maintenance
|
Maintenance procedures, including regular upgrades, zero-downtime deployments, and emergency maintenance protocols.
|
{{< details >}}
- Tier: Ultimate
- Offering: GitLab Dedicated
{{< /details >}}
GitLab Dedicated instances receive regular maintenance to ensure security, reliability, and optimal performance.
## Maintenance windows
GitLab leverages [weekly maintenance windows](../../administration/dedicated/maintenance.md#maintenance-windows) to keep your instance up to date, fix security issues, and ensure the overall reliability and performance of your environment.
## Upgrades and patches
Your instance receives regular upgrades during your preferred maintenance window. These upgrades include the latest patch release for the minor version that is one version behind the current GitLab release. For example, if the latest GitLab version is 16.8, your GitLab Dedicated instance runs on 16.7.
Monthly updates include:
- One minor release
- Two patch releases
To view details about your instance, including upcoming scheduled maintenance and the current GitLab version, sign in to Switchboard.
For more information, see the [GitLab release and maintenance policy](../../policy/maintenance.md).
### Zero-downtime upgrades
Deployments follow the process for [zero-downtime upgrades](../../update/zero_downtime.md) to ensure backward compatibility during an upgrade. When no infrastructure changes or maintenance tasks require downtime, using the instance during an upgrade is possible and safe.
During a GitLab version update, static assets may change and are only available in one of the two versions. To mitigate this situation, three techniques are adopted:
1. Each static asset has a unique name that changes when its content changes.
1. The browser caches each static asset.
1. Each request from the same browser is routed to the same server temporarily.
These techniques together give a strong assurance about asset availability:
- During an upgrade, a user routed to a server running the new version receives assets from the same server, eliminating the risk of receiving a broken page.
- If routed to the old version, a regular user has assets cached in their browser.
- If not cached, they receive the requested page and assets from the same server.
- If the specific server is upgraded during the requests, they may still be routed to another server running the same version.
- If the new server is running the upgraded version, and the requested asset changed, then the page may show some user interface glitches.
The effects of an upgrade are usually unnoticeable. However, in rare cases, a new user might experience temporary interface inconsistencies:
- The user connects for the first time during an upgrade.
- They are initially routed to a server running the old version.
- Their subsequent asset requests are directed to a server with the new version.
- The requested assets have changed in the new version.
If this unlikely sequence occurs, refreshing the page resolves any visual inconsistencies.
{{< alert type="note" >}}
Implementing a caching proxy in your network further reduces this risk.
{{< /alert >}}
## Emergency maintenance
[Emergency maintenance](../../administration/dedicated/maintenance.md#emergency-maintenance) addresses high-severity issues that affect your instance's security, availability, or reliability. When critical patch releases are available, GitLab Dedicated instances are upgraded as soon as possible using emergency maintenance procedures.
|
---
stage: GitLab Dedicated
group: Environment Automation
info: To determine the technical writer assigned to the Stage/Group associated with
this page, see https://handbook.gitlab.com/handbook/product/ux/technical-writing/#assignments
description: Maintenance procedures, including regular upgrades, zero-downtime deployments,
and emergency maintenance protocols.
title: Maintenance
breadcrumbs:
- doc
- subscriptions
- gitlab_dedicated
---
{{< details >}}
- Tier: Ultimate
- Offering: GitLab Dedicated
{{< /details >}}
GitLab Dedicated instances receive regular maintenance to ensure security, reliability, and optimal performance.
## Maintenance windows
GitLab leverages [weekly maintenance windows](../../administration/dedicated/maintenance.md#maintenance-windows) to keep your instance up to date, fix security issues, and ensure the overall reliability and performance of your environment.
## Upgrades and patches
Your instance receives regular upgrades during your preferred maintenance window. These upgrades include the latest patch release for the minor version that is one version behind the current GitLab release. For example, if the latest GitLab version is 16.8, your GitLab Dedicated instance runs on 16.7.
Monthly updates include:
- One minor release
- Two patch releases
To view details about your instance, including upcoming scheduled maintenance and the current GitLab version, sign in to Switchboard.
For more information, see the [GitLab release and maintenance policy](../../policy/maintenance.md).
### Zero-downtime upgrades
Deployments follow the process for [zero-downtime upgrades](../../update/zero_downtime.md) to ensure backward compatibility during an upgrade. When no infrastructure changes or maintenance tasks require downtime, using the instance during an upgrade is possible and safe.
During a GitLab version update, static assets may change and are only available in one of the two versions. To mitigate this situation, three techniques are adopted:
1. Each static asset has a unique name that changes when its content changes.
1. The browser caches each static asset.
1. Each request from the same browser is routed to the same server temporarily.
These techniques together give a strong assurance about asset availability:
- During an upgrade, a user routed to a server running the new version receives assets from the same server, eliminating the risk of receiving a broken page.
- If routed to the old version, a regular user has assets cached in their browser.
- If not cached, they receive the requested page and assets from the same server.
- If the specific server is upgraded during the requests, they may still be routed to another server running the same version.
- If the new server is running the upgraded version, and the requested asset changed, then the page may show some user interface glitches.
The effects of an upgrade are usually unnoticeable. However, in rare cases, a new user might experience temporary interface inconsistencies:
- The user connects for the first time during an upgrade.
- They are initially routed to a server running the old version.
- Their subsequent asset requests are directed to a server with the new version.
- The requested assets have changed in the new version.
If this unlikely sequence occurs, refreshing the page resolves any visual inconsistencies.
{{< alert type="note" >}}
Implementing a caching proxy in your network further reduces this risk.
{{< /alert >}}
## Emergency maintenance
[Emergency maintenance](../../administration/dedicated/maintenance.md#emergency-maintenance) addresses high-severity issues that affect your instance's security, availability, or reliability. When critical patch releases are available, GitLab Dedicated instances are upgraded as soon as possible using emergency maintenance procedures.
|
https://docs.gitlab.com/subscriptions/data_residency_and_high_availability
|
https://gitlab.com/gitlab-org/gitlab/-/tree/master/doc/subscriptions/data_residency_and_high_availability.md
|
2025-08-13
|
doc/subscriptions/gitlab_dedicated
|
[
"doc",
"subscriptions",
"gitlab_dedicated"
] |
data_residency_and_high_availability.md
|
GitLab Dedicated
|
Environment Automation
|
To determine the technical writer assigned to the Stage/Group associated with this page, see https://handbook.gitlab.com/handbook/product/ux/technical-writing/#assignments
|
Data residency and high availability
|
Data residency, isolation, availability, and scalability.
|
{{< details >}}
- Tier: Ultimate
- Offering: GitLab Dedicated
{{< /details >}}
GitLab Dedicated offers enterprise-grade infrastructure and performance in a secure and reliable deployment.
## Data residency
During [onboarding](../../administration/dedicated/create_instance/_index.md#step-2-create-your-gitlab-dedicated-instance), you select the AWS region for your instance deployment and data storage.
Some AWS regions have limited features and may not be available for production instances.
### Available AWS regions
GitLab Dedicated is available in select AWS regions that meet specific requirements, including support for io2 volumes.
The following regions are verified for use:
| Region | Code |
|--------|------|
| Asia Pacific (Mumbai) | `ap-south-1` |
| Asia Pacific (Seoul) | `ap-northeast-2` |
| Asia Pacific (Singapore) | `ap-southeast-1` |
| Asia Pacific (Sydney) | `ap-southeast-2` |
| Asia Pacific (Tokyo) | `ap-northeast-1` |
| Canada (Central) | `ca-central-1` |
| Europe (Frankfurt) | `eu-central-1` |
| Europe (Ireland) | `eu-west-1` |
| Europe (London) | `eu-west-2` |
| Europe (Stockholm) | `eu-north-1` |
| US East (Ohio) | `us-east-2` |
| US East (N. Virginia) | `us-east-1` |
| US West (N. California) | `us-west-1` |
| US West (Oregon) | `us-west-2` |
| Middle East (Bahrain) | `me-south-1` |
For more information about selecting low emission regions, see [Choose Region based on both business requirements and sustainability goals](https://docs.aws.amazon.com/wellarchitected/latest/sustainability-pillar/sus_sus_region_a2.html).
If you're interested in a region not listed here, contact your account representative or [GitLab Support](https://about.gitlab.com/support/) to inquire about availability.
### Secondary regions with limited support
When setting up GitLab Dedicated, you select a secondary region to host a failover instance for
disaster recovery. Some AWS regions are available only as secondary regions because they do not fully support certain AWS
features that GitLab Dedicated relies on. If GitLab initiates a failover to your secondary region during
a disaster recovery event or test, these limitations impact available features.
The following regions are verified for use as a secondary region but with known limitations:
| Region | Code | io2 volume support| AWS SES support |
|--------|------|-------------------|------------|
| Africa (Cape Town) | `af-south-1` | {{< icon name="dash-circle" >}} No | {{< icon name="check-circle-filled" >}} Yes |
| Asia Pacific (Hong Kong) | `ap-east-1` | {{< icon name="check-circle-filled" >}} Yes | {{< icon name="dash-circle" >}} No |
| Asia Pacific (Osaka) | `ap-northeast-3` | {{< icon name="dash-circle" >}} No | {{< icon name="check-circle-filled" >}} Yes |
| Asia Pacific (Hyderabad) | `ap-south-2` | {{< icon name="dash-circle" >}} No | {{< icon name="dash-circle" >}} No |
| Asia Pacific (Jakarta) | `ap-southeast-3` | {{< icon name="dash-circle" >}} No | {{< icon name="check-circle-filled" >}} Yes |
| Asia Pacific (Melbourne) | `ap-southeast-4` | {{< icon name="dash-circle" >}} No | {{< icon name="dash-circle" >}} No |
| Asia Pacific (Malaysia) | `ap-southeast-5` | {{< icon name="dash-circle" >}} No | {{< icon name="dash-circle" >}} No |
| Asia Pacific (Thailand) | `ap-southeast-7` | {{< icon name="dash-circle" >}} No | {{< icon name="dash-circle" >}} No |
| Canada West (Calgary) | `ca-west-1` | {{< icon name="dash-circle" >}} No | {{< icon name="dash-circle" >}} No |
| Europe (Zurich) | `eu-central-2` | {{< icon name="dash-circle" >}} No | {{< icon name="dash-circle" >}} No |
| Europe (Milan) | `eu-south-1` | {{< icon name="dash-circle" >}} No | {{< icon name="check-circle-filled" >}} Yes |
| Europe (Spain) | `eu-south-2` | {{< icon name="dash-circle" >}} No | {{< icon name="dash-circle" >}} No |
| Europe (Paris) | `eu-west-3` | {{< icon name="dash-circle" >}} No | {{< icon name="check-circle-filled" >}} Yes |
| Israel (Tel Aviv) | `il-central-1` | {{< icon name="dash-circle" >}} No | {{< icon name="check-circle-filled" >}} Yes |
| Middle East (UAE) | `me-central-1` | {{< icon name="dash-circle" >}} No | {{< icon name="dash-circle" >}} No |
| Mexico (Central) | `mx-central-1` | {{< icon name="dash-circle" >}} No | {{< icon name="dash-circle" >}} No |
| South America (São Paulo) | `sa-east-1` | {{< icon name="dash-circle" >}} No | {{< icon name="check-circle-filled" >}} Yes |
These limitations may affect your service in the following ways:
- **No io2 volume support**: In regions where AWS does not support io2 volumes, GitLab Dedicated uses GP3
volumes instead. GP3 volumes have lower durability (99.8-99.9% compared to 99.999% for io2), which
increases the risk of disk failures in your replica region. This can affect availability during failover
or while operating in the failed-over state. As a result, these regions are not covered by our standard
recovery time objective (RTO) and recovery point objective (RPO) targets.
- **No SES support**: In regions where AWS does not support Simple Email Service (SES), GitLab
cannot send email notifications using the default configuration. To maintain email functionality
in these regions, set up your own [external SMTP mail service](../../administration/dedicated/configure_instance/users_notifications.md#smtp-email-service).
During onboarding, regions with these limitations are clearly marked. You must acknowledge the
associated risks before selecting one as your secondary region.
## Data isolation
As a single-tenant SaaS solution, GitLab Dedicated provides infrastructure-level isolation:
- Your environment is in an AWS account that is separate from other tenants.
- All necessary infrastructure required to host the GitLab application is contained in the account.
- Your data remains within the account boundary.
- Tenant environments are isolated from GitLab.com.
You administer the application while GitLab manages the underlying infrastructure.
## Availability and scalability
GitLab Dedicated uses modified versions of the [Cloud Native Hybrid reference architectures](../../administration/reference_architectures/_index.md#cloud-native-hybrid) with high availability.
During [onboarding](../../administration/dedicated/create_instance/_index.md#step-2-create-your-gitlab-dedicated-instance), GitLab matches you to the closest reference architecture size based on the number of users.
{{< alert type="note" >}}
While the reference architectures serve as a foundation for GitLab Dedicated environments, they are not exhaustive. Additional cloud provider services beyond the standard reference architectures are used to enhance security and stability. As a result, GitLab Dedicated costs differ from standard reference architecture costs.
{{< /alert >}}
## Disaster recovery
During [onboarding](../../administration/dedicated/create_instance/_index.md#step-2-create-your-gitlab-dedicated-instance),
you specify a secondary AWS region for data storage and recovery. Regular backups of all GitLab Dedicated datastores (including databases and Git repositories) are taken, tested, and stored in your chosen secondary region.
{{< alert type="note" >}}
Some secondary regions have [limited support](#secondary-regions-with-limited-support) for AWS features. These limitations may affect disaster recovery time frames and certain features in your failover instance.
{{< /alert >}}
You can also opt to store backup copies in a separate cloud region for increased redundancy.
For more information, see [disaster recovery for GitLab Dedicated](../../administration/dedicated/disaster_recovery.md).
|
---
stage: GitLab Dedicated
group: Environment Automation
info: To determine the technical writer assigned to the Stage/Group associated with
this page, see https://handbook.gitlab.com/handbook/product/ux/technical-writing/#assignments
description: Data residency, isolation, availability, and scalability.
title: Data residency and high availability
breadcrumbs:
- doc
- subscriptions
- gitlab_dedicated
---
{{< details >}}
- Tier: Ultimate
- Offering: GitLab Dedicated
{{< /details >}}
GitLab Dedicated offers enterprise-grade infrastructure and performance in a secure and reliable deployment.
## Data residency
During [onboarding](../../administration/dedicated/create_instance/_index.md#step-2-create-your-gitlab-dedicated-instance), you select the AWS region for your instance deployment and data storage.
Some AWS regions have limited features and may not be available for production instances.
### Available AWS regions
GitLab Dedicated is available in select AWS regions that meet specific requirements, including support for io2 volumes.
The following regions are verified for use:
| Region | Code |
|--------|------|
| Asia Pacific (Mumbai) | `ap-south-1` |
| Asia Pacific (Seoul) | `ap-northeast-2` |
| Asia Pacific (Singapore) | `ap-southeast-1` |
| Asia Pacific (Sydney) | `ap-southeast-2` |
| Asia Pacific (Tokyo) | `ap-northeast-1` |
| Canada (Central) | `ca-central-1` |
| Europe (Frankfurt) | `eu-central-1` |
| Europe (Ireland) | `eu-west-1` |
| Europe (London) | `eu-west-2` |
| Europe (Stockholm) | `eu-north-1` |
| US East (Ohio) | `us-east-2` |
| US East (N. Virginia) | `us-east-1` |
| US West (N. California) | `us-west-1` |
| US West (Oregon) | `us-west-2` |
| Middle East (Bahrain) | `me-south-1` |
For more information about selecting low emission regions, see [Choose Region based on both business requirements and sustainability goals](https://docs.aws.amazon.com/wellarchitected/latest/sustainability-pillar/sus_sus_region_a2.html).
If you're interested in a region not listed here, contact your account representative or [GitLab Support](https://about.gitlab.com/support/) to inquire about availability.
### Secondary regions with limited support
When setting up GitLab Dedicated, you select a secondary region to host a failover instance for
disaster recovery. Some AWS regions are available only as secondary regions because they do not fully support certain AWS
features that GitLab Dedicated relies on. If GitLab initiates a failover to your secondary region during
a disaster recovery event or test, these limitations impact available features.
The following regions are verified for use as a secondary region but with known limitations:
| Region | Code | io2 volume support| AWS SES support |
|--------|------|-------------------|------------|
| Africa (Cape Town) | `af-south-1` | {{< icon name="dash-circle" >}} No | {{< icon name="check-circle-filled" >}} Yes |
| Asia Pacific (Hong Kong) | `ap-east-1` | {{< icon name="check-circle-filled" >}} Yes | {{< icon name="dash-circle" >}} No |
| Asia Pacific (Osaka) | `ap-northeast-3` | {{< icon name="dash-circle" >}} No | {{< icon name="check-circle-filled" >}} Yes |
| Asia Pacific (Hyderabad) | `ap-south-2` | {{< icon name="dash-circle" >}} No | {{< icon name="dash-circle" >}} No |
| Asia Pacific (Jakarta) | `ap-southeast-3` | {{< icon name="dash-circle" >}} No | {{< icon name="check-circle-filled" >}} Yes |
| Asia Pacific (Melbourne) | `ap-southeast-4` | {{< icon name="dash-circle" >}} No | {{< icon name="dash-circle" >}} No |
| Asia Pacific (Malaysia) | `ap-southeast-5` | {{< icon name="dash-circle" >}} No | {{< icon name="dash-circle" >}} No |
| Asia Pacific (Thailand) | `ap-southeast-7` | {{< icon name="dash-circle" >}} No | {{< icon name="dash-circle" >}} No |
| Canada West (Calgary) | `ca-west-1` | {{< icon name="dash-circle" >}} No | {{< icon name="dash-circle" >}} No |
| Europe (Zurich) | `eu-central-2` | {{< icon name="dash-circle" >}} No | {{< icon name="dash-circle" >}} No |
| Europe (Milan) | `eu-south-1` | {{< icon name="dash-circle" >}} No | {{< icon name="check-circle-filled" >}} Yes |
| Europe (Spain) | `eu-south-2` | {{< icon name="dash-circle" >}} No | {{< icon name="dash-circle" >}} No |
| Europe (Paris) | `eu-west-3` | {{< icon name="dash-circle" >}} No | {{< icon name="check-circle-filled" >}} Yes |
| Israel (Tel Aviv) | `il-central-1` | {{< icon name="dash-circle" >}} No | {{< icon name="check-circle-filled" >}} Yes |
| Middle East (UAE) | `me-central-1` | {{< icon name="dash-circle" >}} No | {{< icon name="dash-circle" >}} No |
| Mexico (Central) | `mx-central-1` | {{< icon name="dash-circle" >}} No | {{< icon name="dash-circle" >}} No |
| South America (São Paulo) | `sa-east-1` | {{< icon name="dash-circle" >}} No | {{< icon name="check-circle-filled" >}} Yes |
These limitations may affect your service in the following ways:
- **No io2 volume support**: In regions where AWS does not support io2 volumes, GitLab Dedicated uses GP3
volumes instead. GP3 volumes have lower durability (99.8-99.9% compared to 99.999% for io2), which
increases the risk of disk failures in your replica region. This can affect availability during failover
or while operating in the failed-over state. As a result, these regions are not covered by our standard
recovery time objective (RTO) and recovery point objective (RPO) targets.
- **No SES support**: In regions where AWS does not support Simple Email Service (SES), GitLab
cannot send email notifications using the default configuration. To maintain email functionality
in these regions, set up your own [external SMTP mail service](../../administration/dedicated/configure_instance/users_notifications.md#smtp-email-service).
During onboarding, regions with these limitations are clearly marked. You must acknowledge the
associated risks before selecting one as your secondary region.
## Data isolation
As a single-tenant SaaS solution, GitLab Dedicated provides infrastructure-level isolation:
- Your environment is in an AWS account that is separate from other tenants.
- All necessary infrastructure required to host the GitLab application is contained in the account.
- Your data remains within the account boundary.
- Tenant environments are isolated from GitLab.com.
You administer the application while GitLab manages the underlying infrastructure.
## Availability and scalability
GitLab Dedicated uses modified versions of the [Cloud Native Hybrid reference architectures](../../administration/reference_architectures/_index.md#cloud-native-hybrid) with high availability.
During [onboarding](../../administration/dedicated/create_instance/_index.md#step-2-create-your-gitlab-dedicated-instance), GitLab matches you to the closest reference architecture size based on the number of users.
{{< alert type="note" >}}
While the reference architectures serve as a foundation for GitLab Dedicated environments, they are not exhaustive. Additional cloud provider services beyond the standard reference architectures are used to enhance security and stability. As a result, GitLab Dedicated costs differ from standard reference architecture costs.
{{< /alert >}}
## Disaster recovery
During [onboarding](../../administration/dedicated/create_instance/_index.md#step-2-create-your-gitlab-dedicated-instance),
you specify a secondary AWS region for data storage and recovery. Regular backups of all GitLab Dedicated datastores (including databases and Git repositories) are taken, tested, and stored in your chosen secondary region.
{{< alert type="note" >}}
Some secondary regions have [limited support](#secondary-regions-with-limited-support) for AWS features. These limitations may affect disaster recovery time frames and certain features in your failover instance.
{{< /alert >}}
You can also opt to store backup copies in a separate cloud region for increased redundancy.
For more information, see [disaster recovery for GitLab Dedicated](../../administration/dedicated/disaster_recovery.md).
|
https://docs.gitlab.com/subscriptions/compute_minutes
|
https://gitlab.com/gitlab-org/gitlab/-/tree/master/doc/subscriptions/compute_minutes.md
|
2025-08-13
|
doc/subscriptions/gitlab_com
|
[
"doc",
"subscriptions",
"gitlab_com"
] |
compute_minutes.md
|
Verify
|
Pipeline Execution
|
To determine the technical writer assigned to the Stage/Group associated with this page, see https://handbook.gitlab.com/handbook/product/ux/technical-writing/#assignments
|
Purchase additional compute minutes
| null |
{{< details >}}
- Tier: Free, Premium, Ultimate
- Offering: GitLab.com
{{< /details >}}
[Compute minutes](../../ci/pipelines/compute_minutes.md) is the resource consumed
when running [CI/CD pipelines](../../ci/_index.md) on GitLab.com instance runners. You can find
pricing for additional compute minutes on the [GitLab Pricing page](https://about.gitlab.com/pricing/#compute-minutes).
Additional compute minutes:
- Are used only after the monthly quota included in your subscription runs out.
- Are [carried over to the next month](#monthly-rollover-of-purchased-compute-minutes),
if any remain at the end of the month.
- Are valid for 12 months from date of purchase if not consumed earlier.
- Expiry of compute minutes is not yet enforced, which allows their use even after the expiry date.
However, GitLab does not guarantee that compute minutes will remain valid after the expiry date.
- Bought on a trial subscription are available after the trial ends or upgrading to a paid plan.
- Remain available when you change subscription tiers, including changes between paid tiers or to the Free tier.
## Purchase compute minutes for a group
Prerequisites:
- You must have the Owner role for the group.
You can purchase additional compute minutes for your group.
You cannot transfer purchased compute minutes from one group to another,
so be sure to select the correct group.
1. Sign in to GitLab.com.
1. On the left sidebar, select **Search or go to** and find your group.
1. Select **Settings > Usage quotas**.
1. Select **Pipelines**.
1. Select **Buy additional compute minutes**. You are taken to the Customers Portal.
1. Enter the desired quantity of compute minute packs.
1. In the **Customer information** section, verify your address.
1. In the **Billing information** section, select a payment method from the dropdown list.
1. Select the **Privacy Statement** and **Terms of Service** checkboxes.
1. Select **Buy compute minutes**.
After your payment is processed, the additional compute minutes are added to your group
namespace.
## Purchase compute minutes for a personal namespace
To purchase additional compute minutes for your personal namespace:
1. Sign in to GitLab.com.
1. On the left sidebar, select your avatar.
1. Select **Edit profile**.
1. On the left sidebar, select **Usage quotas**.
1. Select **Buy additional compute minutes**. You are taken to the Customers Portal.
1. In the **Subscription details** section, select the name of the user from the dropdown list.
1. Enter the desired quantity of compute minute packs.
1. In the **Customer information** section, verify your address.
1. In the **Billing information** section, select a payment method from the dropdown list.
1. Select the **Privacy Statement** and **Terms of Service** checkboxes.
1. Select **Buy compute minutes**.
After your payment is processed, the additional compute minutes are added to your personal
namespace.
## Monthly rollover of purchased compute minutes
If you purchase additional compute minutes and don't use the full amount, the remaining amount
rolls over to the next month. Additional compute minutes are a one-time purchase and
do not renew or refresh each month.
For example, if you have a monthly quota of 10,000 compute minutes:
- On April 1, you purchase 5,000 additional compute minutes, so you have 15,000 minutes
available for April.
- During April, you use 13,000 minutes, so you used 3,000 of the 5,000 additional compute minutes.
- On May 1, [the monthly quota resets](../../ci/pipelines/instance_runner_compute_minutes.md#monthly-reset)
and the unused compute minutes roll over. So you have 2,000 additional compute minutes remaining
and a total of 12,000 available for May.
## Troubleshooting
### Error: `Last name can't be blank`
You might get an error "Last name can't be blank" when purchasing compute minutes.
This issue occurs when a last name is missing from the **Full name** field of your profile.
To resolve the issue:
- Ensure that your user profile has a last name filled in:
1. On the left sidebar, select your avatar.
1. Select **Edit profile**.
1. Update the **Full name** field to have both first name and last name, then save the changes.
- Clear your browser cache and cookies, then try the purchase process again.
- If the error persists, try using a different web browser or an incognito/private browsing window.
### Error: `Attempt_Exceed_Limitation - Attempt exceed the limitation, refresh page to try again`
You might get the error `Attempt_Exceed_Limitation - Attempt exceed the limitation, refresh page to try again.`
when purchasing compute minutes.
This issue occurs when the credit card form is re-submitted too quickly
(three submissions in one minute or six submissions in one hour).
To resolve this issue, wait a few minutes and try the purchase process again.
|
---
stage: Verify
group: Pipeline Execution
info: To determine the technical writer assigned to the Stage/Group associated with
this page, see https://handbook.gitlab.com/handbook/product/ux/technical-writing/#assignments
title: Purchase additional compute minutes
breadcrumbs:
- doc
- subscriptions
- gitlab_com
---
{{< details >}}
- Tier: Free, Premium, Ultimate
- Offering: GitLab.com
{{< /details >}}
[Compute minutes](../../ci/pipelines/compute_minutes.md) is the resource consumed
when running [CI/CD pipelines](../../ci/_index.md) on GitLab.com instance runners. You can find
pricing for additional compute minutes on the [GitLab Pricing page](https://about.gitlab.com/pricing/#compute-minutes).
Additional compute minutes:
- Are used only after the monthly quota included in your subscription runs out.
- Are [carried over to the next month](#monthly-rollover-of-purchased-compute-minutes),
if any remain at the end of the month.
- Are valid for 12 months from date of purchase if not consumed earlier.
- Expiry of compute minutes is not yet enforced, which allows their use even after the expiry date.
However, GitLab does not guarantee that compute minutes will remain valid after the expiry date.
- Bought on a trial subscription are available after the trial ends or upgrading to a paid plan.
- Remain available when you change subscription tiers, including changes between paid tiers or to the Free tier.
## Purchase compute minutes for a group
Prerequisites:
- You must have the Owner role for the group.
You can purchase additional compute minutes for your group.
You cannot transfer purchased compute minutes from one group to another,
so be sure to select the correct group.
1. Sign in to GitLab.com.
1. On the left sidebar, select **Search or go to** and find your group.
1. Select **Settings > Usage quotas**.
1. Select **Pipelines**.
1. Select **Buy additional compute minutes**. You are taken to the Customers Portal.
1. Enter the desired quantity of compute minute packs.
1. In the **Customer information** section, verify your address.
1. In the **Billing information** section, select a payment method from the dropdown list.
1. Select the **Privacy Statement** and **Terms of Service** checkboxes.
1. Select **Buy compute minutes**.
After your payment is processed, the additional compute minutes are added to your group
namespace.
## Purchase compute minutes for a personal namespace
To purchase additional compute minutes for your personal namespace:
1. Sign in to GitLab.com.
1. On the left sidebar, select your avatar.
1. Select **Edit profile**.
1. On the left sidebar, select **Usage quotas**.
1. Select **Buy additional compute minutes**. You are taken to the Customers Portal.
1. In the **Subscription details** section, select the name of the user from the dropdown list.
1. Enter the desired quantity of compute minute packs.
1. In the **Customer information** section, verify your address.
1. In the **Billing information** section, select a payment method from the dropdown list.
1. Select the **Privacy Statement** and **Terms of Service** checkboxes.
1. Select **Buy compute minutes**.
After your payment is processed, the additional compute minutes are added to your personal
namespace.
## Monthly rollover of purchased compute minutes
If you purchase additional compute minutes and don't use the full amount, the remaining amount
rolls over to the next month. Additional compute minutes are a one-time purchase and
do not renew or refresh each month.
For example, if you have a monthly quota of 10,000 compute minutes:
- On April 1, you purchase 5,000 additional compute minutes, so you have 15,000 minutes
available for April.
- During April, you use 13,000 minutes, so you used 3,000 of the 5,000 additional compute minutes.
- On May 1, [the monthly quota resets](../../ci/pipelines/instance_runner_compute_minutes.md#monthly-reset)
and the unused compute minutes roll over. So you have 2,000 additional compute minutes remaining
and a total of 12,000 available for May.
## Troubleshooting
### Error: `Last name can't be blank`
You might get an error "Last name can't be blank" when purchasing compute minutes.
This issue occurs when a last name is missing from the **Full name** field of your profile.
To resolve the issue:
- Ensure that your user profile has a last name filled in:
1. On the left sidebar, select your avatar.
1. Select **Edit profile**.
1. Update the **Full name** field to have both first name and last name, then save the changes.
- Clear your browser cache and cookies, then try the purchase process again.
- If the error persists, try using a different web browser or an incognito/private browsing window.
### Error: `Attempt_Exceed_Limitation - Attempt exceed the limitation, refresh page to try again`
You might get the error `Attempt_Exceed_Limitation - Attempt exceed the limitation, refresh page to try again.`
when purchasing compute minutes.
This issue occurs when the credit card form is re-submitted too quickly
(three submissions in one minute or six submissions in one hour).
To resolve this issue, wait a few minutes and try the purchase process again.
|
https://docs.gitlab.com/subscriptions/gitlab_com
|
https://gitlab.com/gitlab-org/gitlab/-/tree/master/doc/subscriptions/_index.md
|
2025-08-13
|
doc/subscriptions/gitlab_com
|
[
"doc",
"subscriptions",
"gitlab_com"
] |
_index.md
| null | null | null | null | null |
<!-- markdownlint-disable -->
This document was moved to [another location](../manage_users_and_seats.md#gitlabcom-billing-and-usage).
<!-- This redirect file can be deleted after <2025-11-04>. -->
<!-- Redirects that point to other docs in the same project expire in three months. -->
<!-- Redirects that point to docs in a different project or site (for example, link is not relative and starts with `https:`) expire in one year. -->
<!-- Before deletion, see: https://docs.gitlab.com/development/documentation/redirects -->
|
---
redirect_to: ../manage_users_and_seats.md#gitlabcom-billing-and-usage
remove_date: '2025-11-04'
breadcrumbs:
- doc
- subscriptions
- gitlab_com
---
<!-- markdownlint-disable -->
This document was moved to [another location](../manage_users_and_seats.md#gitlabcom-billing-and-usage).
<!-- This redirect file can be deleted after <2025-11-04>. -->
<!-- Redirects that point to other docs in the same project expire in three months. -->
<!-- Redirects that point to docs in a different project or site (for example, link is not relative and starts with `https:`) expire in one year. -->
<!-- Before deletion, see: https://docs.gitlab.com/development/documentation/redirects -->
|
https://docs.gitlab.com/subscriptions/gitlab_subscription_troubleshooting
|
https://gitlab.com/gitlab-org/gitlab/-/tree/master/doc/subscriptions/gitlab_subscription_troubleshooting.md
|
2025-08-13
|
doc/subscriptions/gitlab_com
|
[
"doc",
"subscriptions",
"gitlab_com"
] |
gitlab_subscription_troubleshooting.md
|
Fulfillment
|
Subscription Management
|
To determine the technical writer assigned to the Stage/Group associated with this page, see https://handbook.gitlab.com/handbook/product/ux/technical-writing/#assignments
|
Troubleshooting GitLab subscription
|
Seat usage, compute minutes, storage limits, renewal info.
|
{{< details >}}
- Tier: Premium, Ultimate
- Offering: GitLab.com, GitLab Self-Managed, GitLab Dedicated
{{< /details >}}
When you purchase or use subscriptions for GitLab, you might encounter the following issues.
## Credit card declined
When you purchase a GitLab subscription, your credit card might be declined because:
- The credit card details are incorrect. The most common cause for this is an incomplete or fake address.
- The credit card account has insufficient funds.
- The credit card has expired.
- The transaction exceeds the credit limit or the card's maximum transaction amount.
- The [transaction is not allowed](#error-transaction_not_allowed).
Check with your financial institution to confirm if any of these reasons apply. If they don't
apply, contact [GitLab Support](https://support.gitlab.com/hc/en-us/requests/new?ticket_form_id=360000071293).
### Error: `transaction_not_allowed`
When you purchase a GitLab subscription, you might get an error that states:
```plaintext
Transaction declined.402 - [card_error/card_declined/transaction_not_allowed]
Your card does not support this type of purchase.
```
This error indicates that the type of transaction you are making is restricted by your card issuer.
It is a security measure designed to protect your account.
Your transaction might be declined because of one or more of the following reasons:
- Your card was issued in India and the transaction does not comply with [RBI's e-mandate rules](https://www.rbi.org.in/Scripts/NotificationUser.aspx?Id=12051&Mode=0).
- Your card isn't activated for online purchases.
- Your card has specific usage limitations.
For example, it is a debit card that is limited to local transactions only.
- The transaction triggers your bank's security protocols.
To resolve this issue, try the following:
- For cards issued in India: Process your transaction through an authorized local reseller.
Reach out to one of the following GitLab partners in India:
- [Datamato Technologies Private Limited](https://about.gitlab.com/partners/channel-partners/#/1345598)
- [FineShift Software Private Limited](https://about.gitlab.com/partners/channel-partners/#/1737250)
- For cards issued outside of the United States: Ensure your card is enabled for international use, and verify if there are country-specific restrictions.
- Contact your financial institution: Ask for the reason why your transaction was declined, and request that your card is enabled for this type of transaction.
## Error: `Attempt_Exceed_Limitation`
When you purchase a GitLab subscription, you might get the error
`Attempt_Exceed_Limitation - Attempt exceed the limitation, refresh page to try again.`.
This issue occurs when the credit card form is re-submitted three times within one minute or six times within one hour.
To resolve this issue, wait a few minutes and retry the purchase.
## Error: `Subscription not allowed to add`
When you purchase subscription add-ons (such as additional seats, compute minutes, storage, or GitLab Duo Pro)
you might get the error `Subscription not allowed to add...`.
This issue occurs when you have an active subscription that:
- Was [purchased through a reseller](../customers_portal.md#subscription-purchased-through-a-reseller).
- Is a multi-year subscription.
To resolve this issue, contact your [GitLab sales representative](https://customers.gitlab.com/contact_us) to assist you with the purchase.
## No purchases listed in the Customers Portal account
To view purchases in the Customers Portal on the **Subscriptions & purchases** page,
you must be added as a contact in your organization for the subscription.
To be added as a contact, [create a ticket with the GitLab Support team](https://support.gitlab.com/hc/en-us/requests/new?ticket_form_id=360000071293).
## Unable to link subscription to namespace
On GitLab.com, if you cannot link a subscription to your namespace, you might have insufficient permissions.
Ensure that you have the Owner role for that namespace, and review the [transfer restrictions](../manage_subscription.md#transfer-restrictions).
## Subscription data fails to synchronize
On GitLab Self-Managed or GitLab Dedicated, your subscription data might fail to synchronize.
This issue can occur when network traffic between your GitLab instance and certain
IP addresses is not allowed.
To resolve this issue, allow network traffic from your GitLab instance to the IP addresses
`172.64.146.11:443` and `104.18.41.245:443` (`customers.gitlab.com`).
|
---
stage: Fulfillment
group: Subscription Management
info: To determine the technical writer assigned to the Stage/Group associated with
this page, see https://handbook.gitlab.com/handbook/product/ux/technical-writing/#assignments
description: Seat usage, compute minutes, storage limits, renewal info.
gitlab_dedicated: true
title: Troubleshooting GitLab subscription
breadcrumbs:
- doc
- subscriptions
- gitlab_com
---
{{< details >}}
- Tier: Premium, Ultimate
- Offering: GitLab.com, GitLab Self-Managed, GitLab Dedicated
{{< /details >}}
When you purchase or use subscriptions for GitLab, you might encounter the following issues.
## Credit card declined
When you purchase a GitLab subscription, your credit card might be declined because:
- The credit card details are incorrect. The most common cause for this is an incomplete or fake address.
- The credit card account has insufficient funds.
- The credit card has expired.
- The transaction exceeds the credit limit or the card's maximum transaction amount.
- The [transaction is not allowed](#error-transaction_not_allowed).
Check with your financial institution to confirm if any of these reasons apply. If they don't
apply, contact [GitLab Support](https://support.gitlab.com/hc/en-us/requests/new?ticket_form_id=360000071293).
### Error: `transaction_not_allowed`
When you purchase a GitLab subscription, you might get an error that states:
```plaintext
Transaction declined.402 - [card_error/card_declined/transaction_not_allowed]
Your card does not support this type of purchase.
```
This error indicates that the type of transaction you are making is restricted by your card issuer.
It is a security measure designed to protect your account.
Your transaction might be declined because of one or more of the following reasons:
- Your card was issued in India and the transaction does not comply with [RBI's e-mandate rules](https://www.rbi.org.in/Scripts/NotificationUser.aspx?Id=12051&Mode=0).
- Your card isn't activated for online purchases.
- Your card has specific usage limitations.
For example, it is a debit card that is limited to local transactions only.
- The transaction triggers your bank's security protocols.
To resolve this issue, try the following:
- For cards issued in India: Process your transaction through an authorized local reseller.
Reach out to one of the following GitLab partners in India:
- [Datamato Technologies Private Limited](https://about.gitlab.com/partners/channel-partners/#/1345598)
- [FineShift Software Private Limited](https://about.gitlab.com/partners/channel-partners/#/1737250)
- For cards issued outside of the United States: Ensure your card is enabled for international use, and verify if there are country-specific restrictions.
- Contact your financial institution: Ask for the reason why your transaction was declined, and request that your card is enabled for this type of transaction.
## Error: `Attempt_Exceed_Limitation`
When you purchase a GitLab subscription, you might get the error
`Attempt_Exceed_Limitation - Attempt exceed the limitation, refresh page to try again.`.
This issue occurs when the credit card form is re-submitted three times within one minute or six times within one hour.
To resolve this issue, wait a few minutes and retry the purchase.
## Error: `Subscription not allowed to add`
When you purchase subscription add-ons (such as additional seats, compute minutes, storage, or GitLab Duo Pro)
you might get the error `Subscription not allowed to add...`.
This issue occurs when you have an active subscription that:
- Was [purchased through a reseller](../customers_portal.md#subscription-purchased-through-a-reseller).
- Is a multi-year subscription.
To resolve this issue, contact your [GitLab sales representative](https://customers.gitlab.com/contact_us) to assist you with the purchase.
## No purchases listed in the Customers Portal account
To view purchases in the Customers Portal on the **Subscriptions & purchases** page,
you must be added as a contact in your organization for the subscription.
To be added as a contact, [create a ticket with the GitLab Support team](https://support.gitlab.com/hc/en-us/requests/new?ticket_form_id=360000071293).
## Unable to link subscription to namespace
On GitLab.com, if you cannot link a subscription to your namespace, you might have insufficient permissions.
Ensure that you have the Owner role for that namespace, and review the [transfer restrictions](../manage_subscription.md#transfer-restrictions).
## Subscription data fails to synchronize
On GitLab Self-Managed or GitLab Dedicated, your subscription data might fail to synchronize.
This issue can occur when network traffic between your GitLab instance and certain
IP addresses is not allowed.
To resolve this issue, allow network traffic from your GitLab instance to the IP addresses
`172.64.146.11:443` and `104.18.41.245:443` (`customers.gitlab.com`).
|
https://docs.gitlab.com/subscriptions/gitlab_dedicated_for_government
|
https://gitlab.com/gitlab-org/gitlab/-/tree/master/doc/subscriptions/_index.md
|
2025-08-13
|
doc/subscriptions/gitlab_dedicated_for_government
|
[
"doc",
"subscriptions",
"gitlab_dedicated_for_government"
] |
_index.md
|
GitLab Dedicated
|
US Public Sector Services
|
To determine the technical writer assigned to the Stage/Group associated with this page, see https://handbook.gitlab.com/handbook/product/ux/technical-writing/#assignments
|
GitLab Dedicated for Government
|
Available features and benefits.
|
{{< details >}}
- Tier: Ultimate
- Offering: GitLab Dedicated
{{< /details >}}
GitLab Dedicated for Government is a fully isolated, single-tenant SaaS solution that is:
- Hosted and managed by GitLab, Inc.
- Deployed on [AWS GovCloud](https://docs.aws.amazon.com/govcloud-us/latest/UserGuide/whatis.html) in the US West region.
GitLab Dedicated for Government removes the overhead of platform management to increase your operational efficiency, reduce risk, and enhance the speed and agility of your organization. Each GitLab Dedicated for Government instance is highly available with disaster recovery. GitLab teams fully manage the maintenance and operations of each isolated instance, so customers can access our latest product improvements while meeting the most complex compliance standards. It is built on the same tech stack as GitLab Dedicated and adapted for US government usage.
It's the offering of choice for government agencies and related organizations that need to meet government standards such as FedRAMP compliance.
## Available features
### Data residency
GitLab Dedicated for Government is available in AWS GovCloud and meets US data residency requirements.
### Advanced search
{{< details >}}
- Status: Beta
{{< /details >}}
GitLab Dedicated for Government uses [advanced search](../../user/search/advanced_search.md).
### Availability and scalability
GitLab Dedicated for Government leverages modified versions of the [cloud native hybrid reference architectures](../../administration/reference_architectures/_index.md#cloud-native-hybrid) with high availability enabled. When [onboarding](../../administration/dedicated/create_instance/_index.md#step-2-create-your-gitlab-dedicated-instance), GitLab matches you to the closest reference architecture size based on your number of users.
{{< alert type="note" >}}
The published [reference architectures](../../administration/reference_architectures/_index.md) act as a starting point in defining the cloud resources deployed inside GitLab Dedicated for Government environments, but they are not comprehensive. GitLab Dedicated leverages additional Cloud Provider services beyond what's included in the standard reference architectures for enhanced security and stability of the environment. Therefore, GitLab Dedicated for Government costs differ from standard reference architecture costs.
{{< /alert >}}
#### Disaster recovery
GitLab Dedicated regularly backs up all datastores, including databases and Git repositories. These backups are tested and stored securely. For added redundancy, you can store backup copies in a separate cloud region.
### Security
#### Authentication and authorization
{{< details >}}
- Status: Beta
{{< /details >}}
GitLab Dedicated supports [SAML](../../administration/dedicated/configure_instance/saml.md) and [OpenID Connect (OIDC)](../../administration/dedicated/configure_instance/openid_connect.md) providers for single sign-on (SSO).
You can configure single sign-on (SSO) using the supported providers for authentication. Your instance acts as the service provider, and you provide the necessary configuration for GitLab to communicate with your Identity Providers (IdPs).
#### Encryption
Data is encrypted at rest and in transit using the latest encryption standards.
#### SMTP
{{< details >}}
- Status: Beta
{{< /details >}}
Email sent from GitLab Dedicated uses [Amazon Simple Email Service (Amazon SES)](https://aws.amazon.com/ses/). The connection to Amazon SES is encrypted.
To send application email using an SMTP server instead of Amazon SES, you can [configure your own email service](../../administration/dedicated/configure_instance/users_notifications.md#smtp-email-service).
#### Isolation
As a single-tenant SaaS solution, GitLab Dedicated for Government provides infrastructure-level isolation of your GitLab environment. Your environment is placed into a separate AWS account from other tenants. This AWS account contains all of the underlying infrastructure necessary to host the GitLab application and your data stays within the account boundary. You administer the application while GitLab manages the underlying infrastructure. Tenant environments are also completely isolated from GitLab.com.
#### Access controls
GitLab Dedicated for Government implements strict access controls to protect your environment:
- Follows the principle of least privilege, which grants only the minimum permissions necessary.
- Places tenant AWS accounts under a top-level GitLab Dedicated for Government AWS parent organization.
- Restricts access to the AWS organization to select GitLab team members.
- Implements comprehensive security policies and access requests for user accounts.
- Uses a single Hub account for automated actions and emergency access.
- Uses the GitLab Dedicated Control Plane with the Hub account to perform automated actions over tenant accounts.
GitLab Dedicated engineers do not have direct access to customer tenant environments.
In [break glass](https://gitlab.com/gitlab-com/gl-infra/gitlab-dedicated/team/-/blob/main/engineering/breaking_glass.md)
situations, where access to resources in the tenant environment is required to
address a high-severity issue, GitLab engineers must go through the Hub account
to manage those resources. This is done with an approval process, and after permission
is granted, the engineer assumes an IAM role on a temporary basis to access
tenant resources through the Hub account. All actions in the hub account and
tenant account are logged to CloudTrail.
Inside tenant accounts, GitLab leverages Intrusion Detection and Malware Scanning capabilities from AWS GuardDuty. Infrastructure logs are monitored by the GitLab Security Incident Response Team to detect anomalous events.
### Maintenance
GitLab leverages one weekly maintenance window to keep your instance up to date, fix security issues, and ensure the overall reliability and performance of your environment.
#### Upgrades
GitLab performs monthly upgrades to your instance with the latest patch release during your preferred [maintenance window](../../administration/dedicated/maintenance.md#maintenance-windows) tracking one release behind the latest GitLab release. For example, if the latest version of GitLab available is 16.8, GitLab Dedicated runs on 16.7.
#### Unscheduled maintenance
GitLab may conduct [unscheduled maintenance](../../administration/dedicated/maintenance.md#emergency-maintenance) to address high-severity issues affecting the security, availability, or reliability of your instance.
### Application
GitLab Dedicated for Government comes with the GitLab Self-Managed [Ultimate feature set](https://about.gitlab.com/pricing/feature-comparison/) with the exception of the [unsupported features](#unavailable-features) listed below.
## Unavailable features
### Application features
The following GitLab application features are not available:
- LDAP, smart card, or Kerberos authentication
- Multiple login providers
- FortiAuthenticator, or FortiToken 2FA
- Reply-by email
- Service Desk
- Some GitLab Duo AI capabilities
- View the [list of AI features to see which ones are supported](../../user/gitlab_duo/_index.md).
- For more information, see [category direction - GitLab Dedicated](https://about.gitlab.com/direction/gitlab_dedicated/#supporting-ai-features-on-gitlab-dedicated).
- Features other than [available features](#available-features) that must be configured outside of the GitLab user interface
- Any functionality or feature behind a Feature Flag that is toggled `off` by default.
The following features will not be supported:
- Mattermost
- [Server-side Git hooks](../../administration/server_hooks.md).
GitLab Dedicated for Government is a SaaS service, and access to the underlying infrastructure is only available to GitLab Inc. team members. Due to the nature of server side configuration, there is a possible security concern of running arbitrary code on Dedicated services, as well as the possible impact that can have on the service SLA. Use the alternative [push rules](../../user/project/repository/push_rules.md) or [webhooks](../../user/project/integrations/webhooks.md) instead.
### Operational features
The following operational features are not available:
- Geo
- Self-serve purchasing and configuration
- Multiple login providers
- Support for deploying to non-AWS cloud providers, such as GCP or Azure
- Switchboard
- Pre-Production instance
### Feature flags
GitLab uses [feature flags](../../administration/feature_flags/_index.md) to support the development and rollout of new or experimental features.
In GitLab Dedicated for Government:
- Features behind feature flags that are **enabled by default** are available.
- Features behind feature flags that are **disabled by default** are not available and cannot be enabled by administrators.
Features behind flags that are disabled by default are not ready for production use and therefore unsafe for GitLab Dedicated for Government.
When a feature becomes generally available and the flag is enabled or removed, the feature becomes available in GitLab Dedicated for Government in the same GitLab version.
## Service Level Agreement
The following Service Level Agreement (SLA) targets are defined for GitLab Dedicated for Government:
- Recovery Point Objective (RPO) target: 4 hours.
- Recovery Time Objective (RTO) target: There is no target for RTO. Service is restored on a best-effort basis.
- Service Level Objective (SLO) target: There is no target for SLO.
## Contact sales
For more information about GitLab Dedicated for Government, [contact sales](https://about.gitlab.com/dedicated/) and talk to an expert.
|
---
stage: GitLab Dedicated
group: US Public Sector Services
info: To determine the technical writer assigned to the Stage/Group associated with
this page, see https://handbook.gitlab.com/handbook/product/ux/technical-writing/#assignments
description: Available features and benefits.
title: GitLab Dedicated for Government
breadcrumbs:
- doc
- subscriptions
- gitlab_dedicated_for_government
---
{{< details >}}
- Tier: Ultimate
- Offering: GitLab Dedicated
{{< /details >}}
GitLab Dedicated for Government is a fully isolated, single-tenant SaaS solution that is:
- Hosted and managed by GitLab, Inc.
- Deployed on [AWS GovCloud](https://docs.aws.amazon.com/govcloud-us/latest/UserGuide/whatis.html) in the US West region.
GitLab Dedicated for Government removes the overhead of platform management to increase your operational efficiency, reduce risk, and enhance the speed and agility of your organization. Each GitLab Dedicated for Government instance is highly available with disaster recovery. GitLab teams fully manage the maintenance and operations of each isolated instance, so customers can access our latest product improvements while meeting the most complex compliance standards. It is built on the same tech stack as GitLab Dedicated and adapted for US government usage.
It's the offering of choice for government agencies and related organizations that need to meet government standards such as FedRAMP compliance.
## Available features
### Data residency
GitLab Dedicated for Government is available in AWS GovCloud and meets US data residency requirements.
### Advanced search
{{< details >}}
- Status: Beta
{{< /details >}}
GitLab Dedicated for Government uses [advanced search](../../user/search/advanced_search.md).
### Availability and scalability
GitLab Dedicated for Government leverages modified versions of the [cloud native hybrid reference architectures](../../administration/reference_architectures/_index.md#cloud-native-hybrid) with high availability enabled. When [onboarding](../../administration/dedicated/create_instance/_index.md#step-2-create-your-gitlab-dedicated-instance), GitLab matches you to the closest reference architecture size based on your number of users.
{{< alert type="note" >}}
The published [reference architectures](../../administration/reference_architectures/_index.md) act as a starting point in defining the cloud resources deployed inside GitLab Dedicated for Government environments, but they are not comprehensive. GitLab Dedicated leverages additional Cloud Provider services beyond what's included in the standard reference architectures for enhanced security and stability of the environment. Therefore, GitLab Dedicated for Government costs differ from standard reference architecture costs.
{{< /alert >}}
#### Disaster recovery
GitLab Dedicated regularly backs up all datastores, including databases and Git repositories. These backups are tested and stored securely. For added redundancy, you can store backup copies in a separate cloud region.
### Security
#### Authentication and authorization
{{< details >}}
- Status: Beta
{{< /details >}}
GitLab Dedicated supports [SAML](../../administration/dedicated/configure_instance/saml.md) and [OpenID Connect (OIDC)](../../administration/dedicated/configure_instance/openid_connect.md) providers for single sign-on (SSO).
You can configure single sign-on (SSO) using the supported providers for authentication. Your instance acts as the service provider, and you provide the necessary configuration for GitLab to communicate with your Identity Providers (IdPs).
#### Encryption
Data is encrypted at rest and in transit using the latest encryption standards.
#### SMTP
{{< details >}}
- Status: Beta
{{< /details >}}
Email sent from GitLab Dedicated uses [Amazon Simple Email Service (Amazon SES)](https://aws.amazon.com/ses/). The connection to Amazon SES is encrypted.
To send application email using an SMTP server instead of Amazon SES, you can [configure your own email service](../../administration/dedicated/configure_instance/users_notifications.md#smtp-email-service).
#### Isolation
As a single-tenant SaaS solution, GitLab Dedicated for Government provides infrastructure-level isolation of your GitLab environment. Your environment is placed into a separate AWS account from other tenants. This AWS account contains all of the underlying infrastructure necessary to host the GitLab application and your data stays within the account boundary. You administer the application while GitLab manages the underlying infrastructure. Tenant environments are also completely isolated from GitLab.com.
#### Access controls
GitLab Dedicated for Government implements strict access controls to protect your environment:
- Follows the principle of least privilege, which grants only the minimum permissions necessary.
- Places tenant AWS accounts under a top-level GitLab Dedicated for Government AWS parent organization.
- Restricts access to the AWS organization to select GitLab team members.
- Implements comprehensive security policies and access requests for user accounts.
- Uses a single Hub account for automated actions and emergency access.
- Uses the GitLab Dedicated Control Plane with the Hub account to perform automated actions over tenant accounts.
GitLab Dedicated engineers do not have direct access to customer tenant environments.
In [break glass](https://gitlab.com/gitlab-com/gl-infra/gitlab-dedicated/team/-/blob/main/engineering/breaking_glass.md)
situations, where access to resources in the tenant environment is required to
address a high-severity issue, GitLab engineers must go through the Hub account
to manage those resources. This is done with an approval process, and after permission
is granted, the engineer assumes an IAM role on a temporary basis to access
tenant resources through the Hub account. All actions in the hub account and
tenant account are logged to CloudTrail.
Inside tenant accounts, GitLab leverages Intrusion Detection and Malware Scanning capabilities from AWS GuardDuty. Infrastructure logs are monitored by the GitLab Security Incident Response Team to detect anomalous events.
### Maintenance
GitLab leverages one weekly maintenance window to keep your instance up to date, fix security issues, and ensure the overall reliability and performance of your environment.
#### Upgrades
GitLab performs monthly upgrades to your instance with the latest patch release during your preferred [maintenance window](../../administration/dedicated/maintenance.md#maintenance-windows) tracking one release behind the latest GitLab release. For example, if the latest version of GitLab available is 16.8, GitLab Dedicated runs on 16.7.
#### Unscheduled maintenance
GitLab may conduct [unscheduled maintenance](../../administration/dedicated/maintenance.md#emergency-maintenance) to address high-severity issues affecting the security, availability, or reliability of your instance.
### Application
GitLab Dedicated for Government comes with the GitLab Self-Managed [Ultimate feature set](https://about.gitlab.com/pricing/feature-comparison/) with the exception of the [unsupported features](#unavailable-features) listed below.
## Unavailable features
### Application features
The following GitLab application features are not available:
- LDAP, smart card, or Kerberos authentication
- Multiple login providers
- FortiAuthenticator, or FortiToken 2FA
- Reply-by email
- Service Desk
- Some GitLab Duo AI capabilities
- View the [list of AI features to see which ones are supported](../../user/gitlab_duo/_index.md).
- For more information, see [category direction - GitLab Dedicated](https://about.gitlab.com/direction/gitlab_dedicated/#supporting-ai-features-on-gitlab-dedicated).
- Features other than [available features](#available-features) that must be configured outside of the GitLab user interface
- Any functionality or feature behind a Feature Flag that is toggled `off` by default.
The following features will not be supported:
- Mattermost
- [Server-side Git hooks](../../administration/server_hooks.md).
GitLab Dedicated for Government is a SaaS service, and access to the underlying infrastructure is only available to GitLab Inc. team members. Due to the nature of server side configuration, there is a possible security concern of running arbitrary code on Dedicated services, as well as the possible impact that can have on the service SLA. Use the alternative [push rules](../../user/project/repository/push_rules.md) or [webhooks](../../user/project/integrations/webhooks.md) instead.
### Operational features
The following operational features are not available:
- Geo
- Self-serve purchasing and configuration
- Multiple login providers
- Support for deploying to non-AWS cloud providers, such as GCP or Azure
- Switchboard
- Pre-Production instance
### Feature flags
GitLab uses [feature flags](../../administration/feature_flags/_index.md) to support the development and rollout of new or experimental features.
In GitLab Dedicated for Government:
- Features behind feature flags that are **enabled by default** are available.
- Features behind feature flags that are **disabled by default** are not available and cannot be enabled by administrators.
Features behind flags that are disabled by default are not ready for production use and therefore unsafe for GitLab Dedicated for Government.
When a feature becomes generally available and the flag is enabled or removed, the feature becomes available in GitLab Dedicated for Government in the same GitLab version.
## Service Level Agreement
The following Service Level Agreement (SLA) targets are defined for GitLab Dedicated for Government:
- Recovery Point Objective (RPO) target: 4 hours.
- Recovery Time Objective (RTO) target: There is no target for RTO. Service is restored on a best-effort basis.
- Service Level Objective (SLO) target: There is no target for SLO.
## Contact sales
For more information about GitLab Dedicated for Government, [contact sales](https://about.gitlab.com/dedicated/) and talk to an expert.
|
https://docs.gitlab.com/subscriptions/self_managed
|
https://gitlab.com/gitlab-org/gitlab/-/tree/master/doc/subscriptions/_index.md
|
2025-08-13
|
doc/subscriptions/self_managed
|
[
"doc",
"subscriptions",
"self_managed"
] |
_index.md
| null | null | null | null | null |
<!-- markdownlint-disable -->
This document was moved to [another location](../manage_subscription.md).
<!-- This redirect file can be deleted after <2025-11-04>. -->
<!-- Redirects that point to other docs in the same project expire in three months. -->
<!-- Redirects that point to docs in a different project or site (for example, link is not relative and starts with `https:`) expire in one year. -->
<!-- Before deletion, see: https://docs.gitlab.com/development/documentation/redirects -->
|
---
redirect_to: ../manage_subscription.md
remove_date: '2025-11-04'
breadcrumbs:
- doc
- subscriptions
- self_managed
---
<!-- markdownlint-disable -->
This document was moved to [another location](../manage_subscription.md).
<!-- This redirect file can be deleted after <2025-11-04>. -->
<!-- Redirects that point to other docs in the same project expire in three months. -->
<!-- Redirects that point to docs in a different project or site (for example, link is not relative and starts with `https:`) expire in one year. -->
<!-- Before deletion, see: https://docs.gitlab.com/development/documentation/redirects -->
|
https://docs.gitlab.com/solutions
|
https://gitlab.com/gitlab-org/gitlab/-/tree/master/doc/_index.md
|
2025-08-13
|
doc/solutions
|
[
"doc",
"solutions"
] |
_index.md
|
Solutions Architecture
|
Solutions Architecture
|
This page is owned by the Solutions Architecture team.
|
Solutions architecture
|
Use these reference solutions to integrate GitLab with your people, process, and technology.
|
As with all extensible platforms, GitLab has many features that can be creatively combined together with third party functionality to create solutions that address the specific people, process, and technology challenges of the organizations that use it. Reference solutions and implementations can also be crafted at a more general level so that they can be adopted and customized by customers with similar needs to the reference solution.
This documentation is the home for solutions GitLab wishes to share with customers.
## Relationship to documentation
While information in this section gives valuable and qualified guidance on ways to solve problems by using the GitLab platform, the product documentation is the authoritative reference for product features and functions.
## Solutions categories
- [Cloud Solutions](cloud/_index.md)
- [Coding Languages and Frameworks](languages/_index.md)
- [Integrations](integrations/_index.md)
- [Solution Components](components/_index.md)
## Self-Hosted Model
- [Complete AWS/Google Cloud Deployment Guide with Ollama Integration](integrations/aws_googlecloud_ollama.md)
|
---
stage: Solutions Architecture
group: Solutions Architecture
info: This page is owned by the Solutions Architecture team.
title: Solutions architecture
description: Use these reference solutions to integrate GitLab with your people, process,
and technology.
breadcrumbs:
- doc
- solutions
---
As with all extensible platforms, GitLab has many features that can be creatively combined together with third party functionality to create solutions that address the specific people, process, and technology challenges of the organizations that use it. Reference solutions and implementations can also be crafted at a more general level so that they can be adopted and customized by customers with similar needs to the reference solution.
This documentation is the home for solutions GitLab wishes to share with customers.
## Relationship to documentation
While information in this section gives valuable and qualified guidance on ways to solve problems by using the GitLab platform, the product documentation is the authoritative reference for product features and functions.
## Solutions categories
- [Cloud Solutions](cloud/_index.md)
- [Coding Languages and Frameworks](languages/_index.md)
- [Integrations](integrations/_index.md)
- [Solution Components](components/_index.md)
## Self-Hosted Model
- [Complete AWS/Google Cloud Deployment Guide with Ollama Integration](integrations/aws_googlecloud_ollama.md)
|
https://docs.gitlab.com/solutions/components
|
https://gitlab.com/gitlab-org/gitlab/-/tree/master/doc/solutions/_index.md
|
2025-08-13
|
doc/solutions/components
|
[
"doc",
"solutions",
"components"
] |
_index.md
|
Solutions Architecture
|
Solutions Architecture
|
This page is owned by the Solutions Architecture team.
|
Solution Components
| null |
This documentation section covers a variety of Solution components developed and provided by GitLab.
To download and run these solution components, request your account team for invitation code.
The use of any Solution component is subject to the [GitLab Subscription Agreement](https://handbook.gitlab.com/handbook/legal/subscription-agreement/) (the "Agreement") and constitutes Free Software as defined within the Agreement.
## DevSecOps Workflow
GitLab Solution to provide end to end DevSecOps workflow.
[Mobile Apps](workflow_mobileapps.md)
## Integrated DevSecOps
GitLab Solution to provide an integrated end to end DevSecOps workflow.
[Secure Software Development Workflow Workflow: Snyk SAST](integrated_snyk.md)
[Change Control Workflow: ServiceNow](integrated_servicenow.md)
## By Use Cases
GitLab Solution Packages to provide rules and policies to enforce standards and application security tests
[Secret Detection](secret_detection.md)
[OSS License Check](oss_license_check.md)
## Metrics and KPIs
GitLab Metrics and KPI Dashboard and Solution
[Security Metrics and KPIs Dashboard](securitykpi.md)
Automatically sync Jira incidents to GitLab to unlock DORA metrics tracking. Real-time replication enables Change Failure Rate and Time to Restore Service measurement.
[Jira to GitLab DORA Integration](jira_dora.md)
Automatically sync Jira issues to GitLab to unlock VSA metrics tracking. Real-time replication enables Lead Time, Issues Created, and Issues Closed measurement.
[Jira to GitLab VSA Integration](jira_vsa.md)
## GenAI and Data Science
[Agentic Workflow: Apply Coding Style Guide](duo_workflow/duo_workflow_codestyle.md)
## Compliance and Best Practices
[Guide on Separation of Duties](guide_on_sod.md)
|
---
stage: Solutions Architecture
group: Solutions Architecture
info: This page is owned by the Solutions Architecture team.
title: Solution Components
breadcrumbs:
- doc
- solutions
- components
---
This documentation section covers a variety of Solution components developed and provided by GitLab.
To download and run these solution components, request your account team for invitation code.
The use of any Solution component is subject to the [GitLab Subscription Agreement](https://handbook.gitlab.com/handbook/legal/subscription-agreement/) (the "Agreement") and constitutes Free Software as defined within the Agreement.
## DevSecOps Workflow
GitLab Solution to provide end to end DevSecOps workflow.
[Mobile Apps](workflow_mobileapps.md)
## Integrated DevSecOps
GitLab Solution to provide an integrated end to end DevSecOps workflow.
[Secure Software Development Workflow Workflow: Snyk SAST](integrated_snyk.md)
[Change Control Workflow: ServiceNow](integrated_servicenow.md)
## By Use Cases
GitLab Solution Packages to provide rules and policies to enforce standards and application security tests
[Secret Detection](secret_detection.md)
[OSS License Check](oss_license_check.md)
## Metrics and KPIs
GitLab Metrics and KPI Dashboard and Solution
[Security Metrics and KPIs Dashboard](securitykpi.md)
Automatically sync Jira incidents to GitLab to unlock DORA metrics tracking. Real-time replication enables Change Failure Rate and Time to Restore Service measurement.
[Jira to GitLab DORA Integration](jira_dora.md)
Automatically sync Jira issues to GitLab to unlock VSA metrics tracking. Real-time replication enables Lead Time, Issues Created, and Issues Closed measurement.
[Jira to GitLab VSA Integration](jira_vsa.md)
## GenAI and Data Science
[Agentic Workflow: Apply Coding Style Guide](duo_workflow/duo_workflow_codestyle.md)
## Compliance and Best Practices
[Guide on Separation of Duties](guide_on_sod.md)
|
https://docs.gitlab.com/solutions/jira_dora
|
https://gitlab.com/gitlab-org/gitlab/-/tree/master/doc/solutions/jira_dora.md
|
2025-08-13
|
doc/solutions/components
|
[
"doc",
"solutions",
"components"
] |
jira_dora.md
|
Solutions Architecture
|
Solutions Architecture
|
This page is owned by the Solutions Architecture team.
|
Jira to GitLab DORA Integration
| null |
{{< details >}}
- Tier: Ultimate
- Offering: GitLab.com, GitLab Self-Managed, GitLab Dedicated
{{< /details >}}
With GitLab, you can get visibility into [DORA metrics](../../user/analytics/dora_metrics.md) to help you measure your DevOps performance. The 4 metrics are:
- **Deployment frequency**: average # of deployments per day to production
- **Lead time for changes**: # of seconds to successfully deliver a commit into production (from code committed, to code successfully running in production)
- **Change failure rate**: % of deployments that cause an incident in production in the given time period
- **Time to restore service**: median time an incident was open for on a production environment
While the first two metrics are generated from GitLab CI/CD and Merge Requests, the latter two depend on [GitLab incidents](../../operations/incident_management/manage_incidents.md) being created.
For teams using Jira for incident tracking, this means that incidents need to be replicated from Jira to GitLab in real-time. This project walks through setting up that replication.
**NOTE**: A similar integration exists for issue replication to generate Value Stream Analytics metrics (Lead Time, Issues Created, and Issues Closed). If you're interested in issue replication for VSA metrics, refer to the [Jira to GitLab VSA Integration](jira_vsa.md).
## Architecture
We will need to create 2 automation workflows:
1. Create GitLab incidents when they are created in Jira.
1. Resolve GitLab incidents when they are resolved in Jira.
### Incident Creation
### Incident Resolution
## Setup
### Pre-requisites
This walkthrough assumes that you have:
- a GitLab Ultimate license
- a Jira project to clone incidents from
Jira places [limits](https://www.atlassian.com/software/jira/pricing) on the frequency of Automation runs depending on your Jira license. As of today, the limits are as follows:
| **Tier** | **Limit** |
|------------|------------------------------|
| Free | 100 runs per month |
| Standard | 1700 runs per month |
| Premium | 1000 runs per user per month |
| Enterprise | Unlimited runs |
Each incident creation counts as 1 run, and each incident resolution counts as 1 run.
### GitLab Alert Endpoint
First we'll need to create an HTTP endpoint that can be triggered to create/resolve alerts in GitLab, which in turn create/resolve incidents.
1. Head to your GitLab project where you want Jira incidents to be created. From the sidebar, go to **Settings** > **Monitor**. Expand the **Alerts** section.
1. Under **Alerts**, switch to the **Alert settings** tab. Check the following boxes, and click **Save changes**:
- _Create an incident. Incidents are created for each alert triggered._
- _Automatically close associated incident when a recovery alert notification resolves an alert_
1. Under **Alerts**, switch to the **Current integrations** tab. Click **Add new integration**. Set the **Integration type** to `HTTP Endpoint`, give it a name (e.g. `Jira incident sync`), and set **Enable integration** to **Active**. We will come back to customize the alert payload mapping, once we've set up our Jira automation workflows.
1. Click **Save integration**. A message should appear that says "Integration successfully saved". Click **View URL and authorization key**.
1. We'll need the endpoint URL and authorization key when setting up our Jira automation workflow and Lambda function, so save this for later.
### Jira Incident Creation Workflow
To automatically trigger the GitLab alert endpoint when a Jira incident is created, we'll use [Jira automation](https://community.atlassian.com/t5/Jira-articles/Automation-for-Jira-Send-web-request-using-Jira-REST-API/ba-p/1443828).
1. Navigate to your Jira project where your incidents are managed. From the sidebar, head to **Project settings** > **Automation** (you may have to scroll down a bit to find it).
1. From here we can manage our Jira automation workflows. At the top-right, click **Create rule**.
1. For your trigger, search for and select **Issue created**. Click **Save**.
1. Next, select **IF: Add a condition**. Here you can specify what conditions to check for, in order to determine if the issue created relates to an incident. For this guide, we'll select **Issue fields condition**. Under **Field**, we'll select **Summary**, the **Condition** will be set to **contains**, and the value will be `incident`. Click **Save**.
1. With our trigger and condition set, select **THEN: Add an action**. Search for and select **Send web request**.
1. Set the **Web request URL** to your GitLab **Webhook URL** from the previous section.
1. Check the GitLab docs [here](../../operations/incident_management/integrations.md#authorization) for endpoint authentication options. For this guide, we'll use the [Bearer authorization header](../../operations/incident_management/integrations.md#bearer-authorization-header) method. In your Jira automation configuration, add the following headers:
| Name | Value |
| ------ | ------ |
| Authorization | Bearer \<GitLab endpoint **auth key** from the previous section\> |
| Content-Type | `application/json` |
- You may want to set the `Authorization` header to "Hidden".
1. Make sure the **HTTP method** is set to **POST**, and set **Web request body** to **Issue data (Jira format)**.
1. Finally, click **Save**, give your automation a name (e.g. `Jira incident creation`), and click **Turn it on**. At the top-right, click **Return to list**.
1. The last thing you'll need to do is map the Jira payload values to the GitLab alert parameters. If you're planning to also set up incident resolution for the **Time to restore service** metric, skip this step for now. Otherwise, jump to [Map Jira payload values to GitLab alert parameters](#map-jira-payload-values-to-gitlab-alert-parameters) and follow the steps there.
Once you've mapped the payload values, incidents you create in Jira will also be created in GitLab. This will allow you to see the **Change failure rate** DORA metric.
### Jira Incident Resolution Workflow
Create another Jira automation workflow as described above, with the following changes:
1. Set the trigger to **Issue transitioned**. The "From status" field can be left blank. The "To status" field can be set to any statuses representing a resolved incident as per your workflow (e.g. `Closed`, `Done`, `Resolved`, `Completed`).
1. Make sure to name the automation appropriately (e.g. `Jira incident close`).
### Map Jira payload values to GitLab alert parameters
1. Once you've created your Jira automation workflow, click on the workflow you just created, and select **Then: Send web request**.
1. Expand the **Validate your web request configuration** section, and enter a *resolved* issue key to test with (you must have an existing issue key that you can use). Click **Validate**.
1. Expand the **Request POST** section, and expand the **Payload** section. Copy the entire payload.
1. Head back into your GitLab project, and go to **Settings** > **Monitor** > **Alerts** > **Current Integrations**. Click the 'settings' icon next to the integration you created earlier, and switch to the **Configure details** tab.
1. Under **Customize alert payload mapping**, paste the payload you copied from Jira in step 3. Then click **Parse payload fields**.
1. Map the fields as shown below:
| GitLab alert key | Payload alert key |
| ------ | ------ |
| Title | issue.fields.summary |
| Description | issue.fields.status.description |
| End time | issue.fields.resolutiondate<sup>1</sup> |
| Monitoring tool | issue.fields.reporter.accountType |
| Severity | issue.fields.priority.name |
| Fingerprint | issue.key |
| Environment | issue.fields.project.name |
<sup>1</sup> This is only needed if you set up the incident resolution automation. If this field doesn't appear as an option, make sure you entered a *resolved* issue key to test with in step 2 above.
1. Finally, click **Save integration**.
At this point, incidents you resolve in Jira will also be resolved in GitLab. This will allow you to see the **Time to restore service** DORA metric.
## Resources
- [DORA metrics](../../user/analytics/dora_metrics.md)
- [Measure DORA metrics with Jira](../../user/analytics/dora_metrics.md#with-jira)
- [GitLab incident management](../../operations/incident_management/manage_incidents.md)
- [GitLab HTTP endpoints](../../operations/incident_management/integrations.md#alerting-endpoints)
- [GitLab HTTP endpoint authorization](../../operations/incident_management/integrations.md#authorization)
- [GitLab alert parameters](../../operations/incident_management/integrations.md#customize-the-alert-payload-outside-of-gitlab)
- [GitLab recovery alerts](../../operations/incident_management/integrations.md#recovery-alerts)
- [Jira automation with web requests](https://community.atlassian.com/t5/Jira-articles/Automation-for-Jira-Send-web-request-using-Jira-REST-API/ba-p/1443828)
|
---
stage: Solutions Architecture
group: Solutions Architecture
info: This page is owned by the Solutions Architecture team.
title: Jira to GitLab DORA Integration
breadcrumbs:
- doc
- solutions
- components
---
{{< details >}}
- Tier: Ultimate
- Offering: GitLab.com, GitLab Self-Managed, GitLab Dedicated
{{< /details >}}
With GitLab, you can get visibility into [DORA metrics](../../user/analytics/dora_metrics.md) to help you measure your DevOps performance. The 4 metrics are:
- **Deployment frequency**: average # of deployments per day to production
- **Lead time for changes**: # of seconds to successfully deliver a commit into production (from code committed, to code successfully running in production)
- **Change failure rate**: % of deployments that cause an incident in production in the given time period
- **Time to restore service**: median time an incident was open for on a production environment
While the first two metrics are generated from GitLab CI/CD and Merge Requests, the latter two depend on [GitLab incidents](../../operations/incident_management/manage_incidents.md) being created.
For teams using Jira for incident tracking, this means that incidents need to be replicated from Jira to GitLab in real-time. This project walks through setting up that replication.
**NOTE**: A similar integration exists for issue replication to generate Value Stream Analytics metrics (Lead Time, Issues Created, and Issues Closed). If you're interested in issue replication for VSA metrics, refer to the [Jira to GitLab VSA Integration](jira_vsa.md).
## Architecture
We will need to create 2 automation workflows:
1. Create GitLab incidents when they are created in Jira.
1. Resolve GitLab incidents when they are resolved in Jira.
### Incident Creation
### Incident Resolution
## Setup
### Pre-requisites
This walkthrough assumes that you have:
- a GitLab Ultimate license
- a Jira project to clone incidents from
Jira places [limits](https://www.atlassian.com/software/jira/pricing) on the frequency of Automation runs depending on your Jira license. As of today, the limits are as follows:
| **Tier** | **Limit** |
|------------|------------------------------|
| Free | 100 runs per month |
| Standard | 1700 runs per month |
| Premium | 1000 runs per user per month |
| Enterprise | Unlimited runs |
Each incident creation counts as 1 run, and each incident resolution counts as 1 run.
### GitLab Alert Endpoint
First we'll need to create an HTTP endpoint that can be triggered to create/resolve alerts in GitLab, which in turn create/resolve incidents.
1. Head to your GitLab project where you want Jira incidents to be created. From the sidebar, go to **Settings** > **Monitor**. Expand the **Alerts** section.
1. Under **Alerts**, switch to the **Alert settings** tab. Check the following boxes, and click **Save changes**:
- _Create an incident. Incidents are created for each alert triggered._
- _Automatically close associated incident when a recovery alert notification resolves an alert_
1. Under **Alerts**, switch to the **Current integrations** tab. Click **Add new integration**. Set the **Integration type** to `HTTP Endpoint`, give it a name (e.g. `Jira incident sync`), and set **Enable integration** to **Active**. We will come back to customize the alert payload mapping, once we've set up our Jira automation workflows.
1. Click **Save integration**. A message should appear that says "Integration successfully saved". Click **View URL and authorization key**.
1. We'll need the endpoint URL and authorization key when setting up our Jira automation workflow and Lambda function, so save this for later.
### Jira Incident Creation Workflow
To automatically trigger the GitLab alert endpoint when a Jira incident is created, we'll use [Jira automation](https://community.atlassian.com/t5/Jira-articles/Automation-for-Jira-Send-web-request-using-Jira-REST-API/ba-p/1443828).
1. Navigate to your Jira project where your incidents are managed. From the sidebar, head to **Project settings** > **Automation** (you may have to scroll down a bit to find it).
1. From here we can manage our Jira automation workflows. At the top-right, click **Create rule**.
1. For your trigger, search for and select **Issue created**. Click **Save**.
1. Next, select **IF: Add a condition**. Here you can specify what conditions to check for, in order to determine if the issue created relates to an incident. For this guide, we'll select **Issue fields condition**. Under **Field**, we'll select **Summary**, the **Condition** will be set to **contains**, and the value will be `incident`. Click **Save**.
1. With our trigger and condition set, select **THEN: Add an action**. Search for and select **Send web request**.
1. Set the **Web request URL** to your GitLab **Webhook URL** from the previous section.
1. Check the GitLab docs [here](../../operations/incident_management/integrations.md#authorization) for endpoint authentication options. For this guide, we'll use the [Bearer authorization header](../../operations/incident_management/integrations.md#bearer-authorization-header) method. In your Jira automation configuration, add the following headers:
| Name | Value |
| ------ | ------ |
| Authorization | Bearer \<GitLab endpoint **auth key** from the previous section\> |
| Content-Type | `application/json` |
- You may want to set the `Authorization` header to "Hidden".
1. Make sure the **HTTP method** is set to **POST**, and set **Web request body** to **Issue data (Jira format)**.
1. Finally, click **Save**, give your automation a name (e.g. `Jira incident creation`), and click **Turn it on**. At the top-right, click **Return to list**.
1. The last thing you'll need to do is map the Jira payload values to the GitLab alert parameters. If you're planning to also set up incident resolution for the **Time to restore service** metric, skip this step for now. Otherwise, jump to [Map Jira payload values to GitLab alert parameters](#map-jira-payload-values-to-gitlab-alert-parameters) and follow the steps there.
Once you've mapped the payload values, incidents you create in Jira will also be created in GitLab. This will allow you to see the **Change failure rate** DORA metric.
### Jira Incident Resolution Workflow
Create another Jira automation workflow as described above, with the following changes:
1. Set the trigger to **Issue transitioned**. The "From status" field can be left blank. The "To status" field can be set to any statuses representing a resolved incident as per your workflow (e.g. `Closed`, `Done`, `Resolved`, `Completed`).
1. Make sure to name the automation appropriately (e.g. `Jira incident close`).
### Map Jira payload values to GitLab alert parameters
1. Once you've created your Jira automation workflow, click on the workflow you just created, and select **Then: Send web request**.
1. Expand the **Validate your web request configuration** section, and enter a *resolved* issue key to test with (you must have an existing issue key that you can use). Click **Validate**.
1. Expand the **Request POST** section, and expand the **Payload** section. Copy the entire payload.
1. Head back into your GitLab project, and go to **Settings** > **Monitor** > **Alerts** > **Current Integrations**. Click the 'settings' icon next to the integration you created earlier, and switch to the **Configure details** tab.
1. Under **Customize alert payload mapping**, paste the payload you copied from Jira in step 3. Then click **Parse payload fields**.
1. Map the fields as shown below:
| GitLab alert key | Payload alert key |
| ------ | ------ |
| Title | issue.fields.summary |
| Description | issue.fields.status.description |
| End time | issue.fields.resolutiondate<sup>1</sup> |
| Monitoring tool | issue.fields.reporter.accountType |
| Severity | issue.fields.priority.name |
| Fingerprint | issue.key |
| Environment | issue.fields.project.name |
<sup>1</sup> This is only needed if you set up the incident resolution automation. If this field doesn't appear as an option, make sure you entered a *resolved* issue key to test with in step 2 above.
1. Finally, click **Save integration**.
At this point, incidents you resolve in Jira will also be resolved in GitLab. This will allow you to see the **Time to restore service** DORA metric.
## Resources
- [DORA metrics](../../user/analytics/dora_metrics.md)
- [Measure DORA metrics with Jira](../../user/analytics/dora_metrics.md#with-jira)
- [GitLab incident management](../../operations/incident_management/manage_incidents.md)
- [GitLab HTTP endpoints](../../operations/incident_management/integrations.md#alerting-endpoints)
- [GitLab HTTP endpoint authorization](../../operations/incident_management/integrations.md#authorization)
- [GitLab alert parameters](../../operations/incident_management/integrations.md#customize-the-alert-payload-outside-of-gitlab)
- [GitLab recovery alerts](../../operations/incident_management/integrations.md#recovery-alerts)
- [Jira automation with web requests](https://community.atlassian.com/t5/Jira-articles/Automation-for-Jira-Send-web-request-using-Jira-REST-API/ba-p/1443828)
|
https://docs.gitlab.com/solutions/workflow_mobileapps
|
https://gitlab.com/gitlab-org/gitlab/-/tree/master/doc/solutions/workflow_mobileapps.md
|
2025-08-13
|
doc/solutions/components
|
[
"doc",
"solutions",
"components"
] |
workflow_mobileapps.md
|
Solutions Architecture
|
Solutions Architecture
|
This page is owned by the Solutions Architecture team.
|
DevSecOps Workflow - Mobile Apps
| null |
{{< details >}}
- Tier: Premium, Ultimate
- Offering: GitLab.com, GitLab Self-Managed, GitLab Dedicated
{{< /details >}}
This document provides the instruction and functional detail for GitLab DevSecOps Workflow solution for building and delivering hybrid (React Native) mobile apps.
For native mobile application using fastlane, refer to product documentation.
The instructions include a sample [**React Native**](https://reactnative.dev) application, bootstrapped using `react-native-community/cli`, and provide a cross-platform solution on both iOS and Android devices. The sample project provides an end-to-end solution for using GitLab CI/CD pipelines to build, test and deploy a mobile application.
## Getting Started
Follow the steps below on how to use this React Native Mobile App sample project to jump start your mobile application delivery using GitLab.
### Download the Solution Component
1. Obtain the invitation code from your account team.
1. Download the solution component from [the solution component webstore](https://cloud.gitlab-accelerator-marketplace.com) by using your invitation code.
### Set Up the Solution Component Project
- The Mobile App solution component from the Product Accelerator marketplace has been downloaded. In the solution pack, it includes the mobile app sample project with the CI/CD files.
- Create a new GitLab CI/CD catalog project to host the Snyk component in your environment. In the mobile app solution pack, it includes the Snyk CI/CD component project files which allow you to set up the Snyk CI/CD catalog project.
1. Create a new GitLab project to host this Snyk CI/CD catalog project
1. Copy the provided files into your project
1. Configure the required CI/CD variables in your project settings
1. Make sure the project is marked as a CI/CD catalog project. For more information, see [publish a component project](../../ci/components/_index.md#publish-a-component-project).
{{< alert type="note" >}}
There is a public GitLab Snyk component on GitLab.com, if you are on SaaS, and you are able to access the public GitLab Snyk component, to set up your own Snyk CI/CD catalog project is not needed, and you can follow the documentation in the public GitLab Snyk component on GitLab.com to use the component directly.
{{< /alert >}}
- Use the Change Control Workflow with ServiceNow solution pack to configure the DevOps Change Velocity integration with GitLab to automate change request creation in ServiceNow for deployments require change controls. [Here](../../solutions/components/integrated_servicenow.md) is the documentation link to the change control workflow with ServiceNow solution component, and work with your account team to get an access code to download the Change Control Workflow with ServiceNow solution package.
- Copy the CI YAML files into your project:
- `.gitlab-ci.yml`
- `build-android.yml` in the pipelines directory. You will need to update the file path in `.gitlab-ci.yml` if the `build-android.yml` file is put in a different location other than /pipeline because the main `.gitlab-ci.yml` file references the `build-android.yml` file for the build job.
- `build-ios.yml` in the pipelines directory. You will need to update the file path in `.gitlab-ci.yml` if the `build-ios.yml` file is put in a different location other than /pipeline because the main `.gitlab-ci.yml` file references the `build-ios.yml` file for the build job.
```yaml
include:
- local: "pipelines/build-ios.yml"
inputs:
image: macos-15-xcode-16
tag: saas-macos-medium-m1
- local: "pipelines/build-android.yml"
inputs:
image: reactnativecommunity/react-native-android
```
- Configure the required CI/CD variables in your project settings. See the following section to learn how the pipeline works.
## How the Pipeline Works
This pipeline is designed for a React Native project, handling both iOS and Android builds, test and deploy the Mobile App.
This project includes a simple reactCounter demo app for React Native build for both iOS and Android. This version does not sign the artifacts yet, so we cannot upload to TestFlight or the Play Store.
Each change uses a component for semantic versioning bumps, which has that version stored as an ephemeral variable used to commit
generic packages to the package registry.
## Pipeline Structure
The pipeline consists of the following stages and jobs:
1. prebuild
- unit test
- Snyk scans
1. build
- build IoS package
- build Android package
1. test
- dependency scanning
- SAST scanning
1. functional-test
- upload_ios/android_app_to_sauce_labs
- automated_test_appium_saucelabs
1. app-distribution
- app_distribution_sauce_android
- app_distribution_sauce_ios
1. beta-release
- beta-release-dev
- beta-release-approval
## Prerequisites
There are multiple third party tools integrated in the mobile pipeline workflow. In order to successfully run the pipeline, make sure the following prerequisites are in place.
### Snyk Integration using the Component
In order to use the GitLab Snyk CI/CD component for security scans, make sure your group or project in GitLab is already connected with Snyk, if not, follow [this tutorial](https://docs.snyk.io/scm-ide-and-ci-cd-integrations/snyk-scm-integrations/gitlab) to configure it.
In the mobile app project, add the required variables for the Snyk integration.
#### Required CI/CD Variables
| Variable | Description | Example Value |
|----------|-------------|---------------|
| `SNYK_TOKEN` | API token to access Snyk | `d7da134c-xxxxxxxxxx` |
This mobile app demo project uses a private Snyk component, that's the reason why we added the following additional variables for the mobile app project to access the private Snyk component project, but this is not needed if your Snyk component is public or accessible within your group.
```yaml
SNYK_PROJECT_ACCESS_USERNAME: "MOBILE_APP_SNYK_COMPONENT_ACCESS"
DOCKER_AUTH_CONFIG: '{"auths":{"registry.gitlab.com":{"username":"$SNYK_PROJECT_ACCESS_USERNAME","password":"$SNYK_PROJECT_ACCESS_TOKEN"}}}'
```
#### Update the component path
Update the component path in the `.gitlab-ci.yml` file so that the pipeline can successfully reference the Snyk component.
```yaml
- component: $CI_SERVER_FQDN/gitlab-com/product-accelerator/work-streams/packaging/snyk/snyk@1.0.0 #snky sast scan, this examples uses the component in GitLab the product accelerator group. Please update the path and stage accordingly.
inputs:
stage: prebuild
token: $SNYK_TOKEN
```
### Sauce Labs Intergration
This mobile app demo project CI/CD is integrated with Sauce Labs for automated functional testing. In order to run the automated test in Sauce Labs, the application needs to be uploaded into Sauce Labs app storage. You will need to set the required variables for the project in GitLab to access Sauce Labs and upload the artifacts.
#### Required CI/CD Variables
| Variable | Description | Example Value |
|----------|-------------|---------------|
| `SAUCE_USERNAME` | Sauce Labs username| `rz` |
| `SAUCE_ACCESS_KEY` | API key to access Sauce Labs | `9f5wewwc-xxxxxxx` |
| `APP_FILE_PATH_IOS` | file path to find the build artifacts | `ios/build/reactCounter.ipa` |
| `APP_FILE_PATH_ANDROID` | file path to find the build artifacts | `android/app/build/outputs/apk/release/app-release.apk` |
#### Use Appium for automated testing
In order to use SauceLabs for automated testing, the app has to be uploaded to SauceLab App Management. The pipeline uses the API endpoint to upload the app to SauceLabs and make it available for testing.
Added an Appium test script file in `tests/appium`for testing the React Native mobile application using WebdriverIO and Sauce Labs. The test script will use the following environment variables to access SauceLabs
``` bash
# Using the variables defined in the project
const SAUCE_USERNAME = process.env.SAUCE_USERNAME;
const SAUCE_ACCESS_KEY = process.env.SAUCE_ACCESS_KEY;
```
#### App Distribution (Android and iOS)
GitLab pipeline distributes the app builds to SauceLabs TestFairy for demo purposes. SauceLabs TestFairy allows users to get new versions of the app to testers for review and testing.
### ServiceNow Integration
This mobile app demo project CI/CD is integrated with ServiceNow for change controls. When the pipeline reaches the deployment job that has the change control enabled in ServiceNow, it will automatically create a change request. Once the change request is approved, the deployment job will resume. With this demo project, the beta release approval job is gated in ServiceNow and requires manual approval to proceed.
#### CI/CD Variables
In order for the pipeline to communicate with ServiceNow, the webhook integrations need to be created. If you are using API endpoints to communicates with ServiceNow, you will need to include the following variables. However, this is not required when using the ServiceNow DevOps Change Velocity integration. As part of the ServiceNow DevOps Change Velocity onboarding, the webhooks will be created.
| Variable | Description | Example Value |
|----------|-------------|---------------|
| `SNOW_URL` | URL of your SeriveNow instance| `https://<SNOW_INSTANCE>.com/` |
| `SNOW_TOOLID` | ServiceNow instance ID | `3b5w345629212105c5ddaccwonworw2` |
| `SNOW_TOKEN` | API token to access ServiceNow| `Oxxxxxxxxxx` |
## Included Files and Components
The mobile app project pipeline includes several external configurations and components:
- Local build configurations for iOS and Android
- SAST (Static Application Security Testing) component
- Auto-semversioning component
- Dependency scanning
- Snyk SAST scan component
## Notes
Reach out to your account team for obtaining an invitation code to access the solution component and for any additional questions.
|
---
stage: Solutions Architecture
group: Solutions Architecture
info: This page is owned by the Solutions Architecture team.
title: DevSecOps Workflow - Mobile Apps
breadcrumbs:
- doc
- solutions
- components
---
{{< details >}}
- Tier: Premium, Ultimate
- Offering: GitLab.com, GitLab Self-Managed, GitLab Dedicated
{{< /details >}}
This document provides the instruction and functional detail for GitLab DevSecOps Workflow solution for building and delivering hybrid (React Native) mobile apps.
For native mobile application using fastlane, refer to product documentation.
The instructions include a sample [**React Native**](https://reactnative.dev) application, bootstrapped using `react-native-community/cli`, and provide a cross-platform solution on both iOS and Android devices. The sample project provides an end-to-end solution for using GitLab CI/CD pipelines to build, test and deploy a mobile application.
## Getting Started
Follow the steps below on how to use this React Native Mobile App sample project to jump start your mobile application delivery using GitLab.
### Download the Solution Component
1. Obtain the invitation code from your account team.
1. Download the solution component from [the solution component webstore](https://cloud.gitlab-accelerator-marketplace.com) by using your invitation code.
### Set Up the Solution Component Project
- The Mobile App solution component from the Product Accelerator marketplace has been downloaded. In the solution pack, it includes the mobile app sample project with the CI/CD files.
- Create a new GitLab CI/CD catalog project to host the Snyk component in your environment. In the mobile app solution pack, it includes the Snyk CI/CD component project files which allow you to set up the Snyk CI/CD catalog project.
1. Create a new GitLab project to host this Snyk CI/CD catalog project
1. Copy the provided files into your project
1. Configure the required CI/CD variables in your project settings
1. Make sure the project is marked as a CI/CD catalog project. For more information, see [publish a component project](../../ci/components/_index.md#publish-a-component-project).
{{< alert type="note" >}}
There is a public GitLab Snyk component on GitLab.com, if you are on SaaS, and you are able to access the public GitLab Snyk component, to set up your own Snyk CI/CD catalog project is not needed, and you can follow the documentation in the public GitLab Snyk component on GitLab.com to use the component directly.
{{< /alert >}}
- Use the Change Control Workflow with ServiceNow solution pack to configure the DevOps Change Velocity integration with GitLab to automate change request creation in ServiceNow for deployments require change controls. [Here](../../solutions/components/integrated_servicenow.md) is the documentation link to the change control workflow with ServiceNow solution component, and work with your account team to get an access code to download the Change Control Workflow with ServiceNow solution package.
- Copy the CI YAML files into your project:
- `.gitlab-ci.yml`
- `build-android.yml` in the pipelines directory. You will need to update the file path in `.gitlab-ci.yml` if the `build-android.yml` file is put in a different location other than /pipeline because the main `.gitlab-ci.yml` file references the `build-android.yml` file for the build job.
- `build-ios.yml` in the pipelines directory. You will need to update the file path in `.gitlab-ci.yml` if the `build-ios.yml` file is put in a different location other than /pipeline because the main `.gitlab-ci.yml` file references the `build-ios.yml` file for the build job.
```yaml
include:
- local: "pipelines/build-ios.yml"
inputs:
image: macos-15-xcode-16
tag: saas-macos-medium-m1
- local: "pipelines/build-android.yml"
inputs:
image: reactnativecommunity/react-native-android
```
- Configure the required CI/CD variables in your project settings. See the following section to learn how the pipeline works.
## How the Pipeline Works
This pipeline is designed for a React Native project, handling both iOS and Android builds, test and deploy the Mobile App.
This project includes a simple reactCounter demo app for React Native build for both iOS and Android. This version does not sign the artifacts yet, so we cannot upload to TestFlight or the Play Store.
Each change uses a component for semantic versioning bumps, which has that version stored as an ephemeral variable used to commit
generic packages to the package registry.
## Pipeline Structure
The pipeline consists of the following stages and jobs:
1. prebuild
- unit test
- Snyk scans
1. build
- build IoS package
- build Android package
1. test
- dependency scanning
- SAST scanning
1. functional-test
- upload_ios/android_app_to_sauce_labs
- automated_test_appium_saucelabs
1. app-distribution
- app_distribution_sauce_android
- app_distribution_sauce_ios
1. beta-release
- beta-release-dev
- beta-release-approval
## Prerequisites
There are multiple third party tools integrated in the mobile pipeline workflow. In order to successfully run the pipeline, make sure the following prerequisites are in place.
### Snyk Integration using the Component
In order to use the GitLab Snyk CI/CD component for security scans, make sure your group or project in GitLab is already connected with Snyk, if not, follow [this tutorial](https://docs.snyk.io/scm-ide-and-ci-cd-integrations/snyk-scm-integrations/gitlab) to configure it.
In the mobile app project, add the required variables for the Snyk integration.
#### Required CI/CD Variables
| Variable | Description | Example Value |
|----------|-------------|---------------|
| `SNYK_TOKEN` | API token to access Snyk | `d7da134c-xxxxxxxxxx` |
This mobile app demo project uses a private Snyk component, that's the reason why we added the following additional variables for the mobile app project to access the private Snyk component project, but this is not needed if your Snyk component is public or accessible within your group.
```yaml
SNYK_PROJECT_ACCESS_USERNAME: "MOBILE_APP_SNYK_COMPONENT_ACCESS"
DOCKER_AUTH_CONFIG: '{"auths":{"registry.gitlab.com":{"username":"$SNYK_PROJECT_ACCESS_USERNAME","password":"$SNYK_PROJECT_ACCESS_TOKEN"}}}'
```
#### Update the component path
Update the component path in the `.gitlab-ci.yml` file so that the pipeline can successfully reference the Snyk component.
```yaml
- component: $CI_SERVER_FQDN/gitlab-com/product-accelerator/work-streams/packaging/snyk/snyk@1.0.0 #snky sast scan, this examples uses the component in GitLab the product accelerator group. Please update the path and stage accordingly.
inputs:
stage: prebuild
token: $SNYK_TOKEN
```
### Sauce Labs Intergration
This mobile app demo project CI/CD is integrated with Sauce Labs for automated functional testing. In order to run the automated test in Sauce Labs, the application needs to be uploaded into Sauce Labs app storage. You will need to set the required variables for the project in GitLab to access Sauce Labs and upload the artifacts.
#### Required CI/CD Variables
| Variable | Description | Example Value |
|----------|-------------|---------------|
| `SAUCE_USERNAME` | Sauce Labs username| `rz` |
| `SAUCE_ACCESS_KEY` | API key to access Sauce Labs | `9f5wewwc-xxxxxxx` |
| `APP_FILE_PATH_IOS` | file path to find the build artifacts | `ios/build/reactCounter.ipa` |
| `APP_FILE_PATH_ANDROID` | file path to find the build artifacts | `android/app/build/outputs/apk/release/app-release.apk` |
#### Use Appium for automated testing
In order to use SauceLabs for automated testing, the app has to be uploaded to SauceLab App Management. The pipeline uses the API endpoint to upload the app to SauceLabs and make it available for testing.
Added an Appium test script file in `tests/appium`for testing the React Native mobile application using WebdriverIO and Sauce Labs. The test script will use the following environment variables to access SauceLabs
``` bash
# Using the variables defined in the project
const SAUCE_USERNAME = process.env.SAUCE_USERNAME;
const SAUCE_ACCESS_KEY = process.env.SAUCE_ACCESS_KEY;
```
#### App Distribution (Android and iOS)
GitLab pipeline distributes the app builds to SauceLabs TestFairy for demo purposes. SauceLabs TestFairy allows users to get new versions of the app to testers for review and testing.
### ServiceNow Integration
This mobile app demo project CI/CD is integrated with ServiceNow for change controls. When the pipeline reaches the deployment job that has the change control enabled in ServiceNow, it will automatically create a change request. Once the change request is approved, the deployment job will resume. With this demo project, the beta release approval job is gated in ServiceNow and requires manual approval to proceed.
#### CI/CD Variables
In order for the pipeline to communicate with ServiceNow, the webhook integrations need to be created. If you are using API endpoints to communicates with ServiceNow, you will need to include the following variables. However, this is not required when using the ServiceNow DevOps Change Velocity integration. As part of the ServiceNow DevOps Change Velocity onboarding, the webhooks will be created.
| Variable | Description | Example Value |
|----------|-------------|---------------|
| `SNOW_URL` | URL of your SeriveNow instance| `https://<SNOW_INSTANCE>.com/` |
| `SNOW_TOOLID` | ServiceNow instance ID | `3b5w345629212105c5ddaccwonworw2` |
| `SNOW_TOKEN` | API token to access ServiceNow| `Oxxxxxxxxxx` |
## Included Files and Components
The mobile app project pipeline includes several external configurations and components:
- Local build configurations for iOS and Android
- SAST (Static Application Security Testing) component
- Auto-semversioning component
- Dependency scanning
- Snyk SAST scan component
## Notes
Reach out to your account team for obtaining an invitation code to access the solution component and for any additional questions.
|
https://docs.gitlab.com/solutions/secret_detection
|
https://gitlab.com/gitlab-org/gitlab/-/tree/master/doc/solutions/secret_detection.md
|
2025-08-13
|
doc/solutions/components
|
[
"doc",
"solutions",
"components"
] |
secret_detection.md
|
Solutions Architecture
|
Solutions Architecture
|
This page is owned by the Solutions Architecture team.
|
Secret Detection
| null |
{{< details >}}
- Tier: Ultimate
- Offering: GitLab.com, GitLab Self-Managed, GitLab Dedicated
{{< /details >}}
## Getting Started
### Download the Solution Component
1. Obtain the invitation code from your account team.
1. Download the solution component from [the solution component webstore](https://cloud.gitlab-accelerator-marketplace.com) by using your invitation code.
### Prerequisites
- GitLab Ultimate tier
- Administrator access to your GitLab instance or group
- [Secret Detection](../../user/application_security/secret_detection/_index.md) enabled for your projects
## Configure Secret Detection Custom Rules
This guide helps you implement Secret Detection Policy at the global level. This solution extends the default secret detection rules to include the detection of PII data elements like Social Security Number and passwords in clear text. The rule extension is considered as the remote ruleset.
### Configure Custom Ruleset
You can set up custom ruleset with the following steps
1. Create a top level group `Secret Detection`
1. From your downloaded component, copy the project `Secret Detection Custom Ruleset` into your newly created `Secret Detection` group.
This custom ruleset extends GitLab pre-build rules. The extension can detect and alert secrets including:
- PII data elements: social security number
- Passwords in plain text.
#### Custom Ruleset File
The custom ruleset is defined in `.gitlab/secret-detection-ruleset.toml`
The rules can be defined using `regex`
#### PII Data Element Detection
The extended rules for PII data element detection
```toml
[[rules]]
id = "ssn"
description = "Social Security Number"
regex = "[0-9]{3}-[0-9]{2}-[0-9]{4}"
tags = ["ssn", "social-security-number"]
keywords = ["ssn"]
```
#### Password in Plain Text
The extended rules for password in plain text
```toml
[[rules]]
id = "password-secret"
description = "Detect secrets starting with Password or PASSWORD"
regex = "(?i)Password[:=]\\s*['\"]?[^'\"]+['\"]?"
tags = ["password", "secret"]
keywords = ["password", "PASSWORD"]
```
### Access Defined Custom Ruleset
In order to access the custom ruleset, you need to create a group access token which generates a bot user. The bot user can be used to authenticate and access the custom ruleset by any projects that run the secret detection with the global policy.
To set the access and authentication, follow these steps:
1. Create a group token: In the group `Secret Detection`, create a group access token `Secret Detection Group Token` under `Settings` menu option, give the token `reporter` role with `read_repository` access
1. Create a group variable: Copy the token value and store safely. Add a group variable under `Settings` menu option called `SECRET_DETECTION_GROUP_TOKEN` as the key with the token value.
1. Obtain the group token bot user: In the same group, navigate to `manage` menu option to select `member` and look up corresponding bot user for the group access token `Secrete Detection Group Token`, copy the value representing the bot user for the group in the format of `@group_[group_id]_bot_[random_number]`
## Implementation Guide
This guide covers the steps to configure the policy to run secret detection for all projects using centralized custom ruleset.
### Configure Secret Detection Policy
To run secret detection automatically in the pipeline as the enforced global policy,
set up the policy at the highest level (in this case, for the top-level group).
To create the new secret detection policy:
1. Create the policy: In the same group `Secret Detection`, navigate to that group's **Secure > Policies** page.
1. Select **New policy**.
1. Select **Scan execution policy**.
1. Configure the policy: Give the policy name `Secret Detection Policy` and enter a description and select `Secret Detection` scan
1. Set the **Policy scope** by selecting either "All projects in this group" (and optionally set exceptions) or "Specific projects" (and select the projects from the dropdown).
1. Under the **Actions** section, "Secret Detection" is shown as default.
1. Under the **Conditions** section, you can optionally change "Triggers:" to "Schedules:" if you want to run the scan on a schedule instead of at every commit.
1. Setup access to the custom ruleset: add CI variables with the value of the bot user, group variable and the URL of the custom ruleset project.
The custom ruleset is hosted in a different project and considered as the remote ruleset, so the `SECRET_DETECTION_RULESET_GIT_REFERENCE` must be used.
```yaml
variables:
SECRET_DETECTION_RULESET_GIT_REFERENCE: "group_[group_id]_bot_[random_number]:$SECRET_DETECTION_GROUP_TOKEN@[custom ruleset project URL]"
SECRET_DETECTION_HISTORIC_SCAN: "true"
```
The UI configuration is shown in this screen: 
For detailed information about this CI variable, see [this document for details](../../user/application_security/secret_detection/pipeline/configure.md#with-a-remote-ruleset).
1. Click **Create policy**.
### Complete Policy Configuration
Upon creating the policy, for reference, here is the complete policy configuration:
```yaml
---
scan_execution_policy:
- name: Scan Execution for Secret Detection with Custom Rules
description: ''
enabled: true
policy_scope:
projects:
excluding: []
rules:
- type: pipeline
branches:
- "*"
actions:
- scan: secret_detection
variables:
SECRET_DETECTION_RULESET_GIT_REFERENCE: "@group_[group_id]_bot_[random_number]:$SECRET_DETECTION_GROUP_TOKEN@gitlab.com/example_group/secret-detection/secret-detection-custom-ruleset"
SECRET_DETECTION_HISTORIC_SCAN: 'true'
skip_ci:
allowed: true
allowlist:
users: []
approval_policy: []
```
## How It Works
Once the policy is running. all the projects associated with the global policy will have the `secret detect` job will run automatically in the pipeline as `secret_detection_0` job.
Secrets will be detected and surfaced. If there is a merge request, the net new secrets will be displayed in the MR widget. If it is the default branch merged, they will be shown in the security vulnerability report as following:
The following is an example password in clear text:
## Troubleshooting
### Policy not applying
Ensure the security policy project you modified is correctly linked to your group. See [Link to a security policy project](../../user/application_security/policies/enforcement/security_policy_projects.md#link-to-a-security-policy-project) for more.
|
---
stage: Solutions Architecture
group: Solutions Architecture
info: This page is owned by the Solutions Architecture team.
title: Secret Detection
breadcrumbs:
- doc
- solutions
- components
---
{{< details >}}
- Tier: Ultimate
- Offering: GitLab.com, GitLab Self-Managed, GitLab Dedicated
{{< /details >}}
## Getting Started
### Download the Solution Component
1. Obtain the invitation code from your account team.
1. Download the solution component from [the solution component webstore](https://cloud.gitlab-accelerator-marketplace.com) by using your invitation code.
### Prerequisites
- GitLab Ultimate tier
- Administrator access to your GitLab instance or group
- [Secret Detection](../../user/application_security/secret_detection/_index.md) enabled for your projects
## Configure Secret Detection Custom Rules
This guide helps you implement Secret Detection Policy at the global level. This solution extends the default secret detection rules to include the detection of PII data elements like Social Security Number and passwords in clear text. The rule extension is considered as the remote ruleset.
### Configure Custom Ruleset
You can set up custom ruleset with the following steps
1. Create a top level group `Secret Detection`
1. From your downloaded component, copy the project `Secret Detection Custom Ruleset` into your newly created `Secret Detection` group.
This custom ruleset extends GitLab pre-build rules. The extension can detect and alert secrets including:
- PII data elements: social security number
- Passwords in plain text.
#### Custom Ruleset File
The custom ruleset is defined in `.gitlab/secret-detection-ruleset.toml`
The rules can be defined using `regex`
#### PII Data Element Detection
The extended rules for PII data element detection
```toml
[[rules]]
id = "ssn"
description = "Social Security Number"
regex = "[0-9]{3}-[0-9]{2}-[0-9]{4}"
tags = ["ssn", "social-security-number"]
keywords = ["ssn"]
```
#### Password in Plain Text
The extended rules for password in plain text
```toml
[[rules]]
id = "password-secret"
description = "Detect secrets starting with Password or PASSWORD"
regex = "(?i)Password[:=]\\s*['\"]?[^'\"]+['\"]?"
tags = ["password", "secret"]
keywords = ["password", "PASSWORD"]
```
### Access Defined Custom Ruleset
In order to access the custom ruleset, you need to create a group access token which generates a bot user. The bot user can be used to authenticate and access the custom ruleset by any projects that run the secret detection with the global policy.
To set the access and authentication, follow these steps:
1. Create a group token: In the group `Secret Detection`, create a group access token `Secret Detection Group Token` under `Settings` menu option, give the token `reporter` role with `read_repository` access
1. Create a group variable: Copy the token value and store safely. Add a group variable under `Settings` menu option called `SECRET_DETECTION_GROUP_TOKEN` as the key with the token value.
1. Obtain the group token bot user: In the same group, navigate to `manage` menu option to select `member` and look up corresponding bot user for the group access token `Secrete Detection Group Token`, copy the value representing the bot user for the group in the format of `@group_[group_id]_bot_[random_number]`
## Implementation Guide
This guide covers the steps to configure the policy to run secret detection for all projects using centralized custom ruleset.
### Configure Secret Detection Policy
To run secret detection automatically in the pipeline as the enforced global policy,
set up the policy at the highest level (in this case, for the top-level group).
To create the new secret detection policy:
1. Create the policy: In the same group `Secret Detection`, navigate to that group's **Secure > Policies** page.
1. Select **New policy**.
1. Select **Scan execution policy**.
1. Configure the policy: Give the policy name `Secret Detection Policy` and enter a description and select `Secret Detection` scan
1. Set the **Policy scope** by selecting either "All projects in this group" (and optionally set exceptions) or "Specific projects" (and select the projects from the dropdown).
1. Under the **Actions** section, "Secret Detection" is shown as default.
1. Under the **Conditions** section, you can optionally change "Triggers:" to "Schedules:" if you want to run the scan on a schedule instead of at every commit.
1. Setup access to the custom ruleset: add CI variables with the value of the bot user, group variable and the URL of the custom ruleset project.
The custom ruleset is hosted in a different project and considered as the remote ruleset, so the `SECRET_DETECTION_RULESET_GIT_REFERENCE` must be used.
```yaml
variables:
SECRET_DETECTION_RULESET_GIT_REFERENCE: "group_[group_id]_bot_[random_number]:$SECRET_DETECTION_GROUP_TOKEN@[custom ruleset project URL]"
SECRET_DETECTION_HISTORIC_SCAN: "true"
```
The UI configuration is shown in this screen: 
For detailed information about this CI variable, see [this document for details](../../user/application_security/secret_detection/pipeline/configure.md#with-a-remote-ruleset).
1. Click **Create policy**.
### Complete Policy Configuration
Upon creating the policy, for reference, here is the complete policy configuration:
```yaml
---
scan_execution_policy:
- name: Scan Execution for Secret Detection with Custom Rules
description: ''
enabled: true
policy_scope:
projects:
excluding: []
rules:
- type: pipeline
branches:
- "*"
actions:
- scan: secret_detection
variables:
SECRET_DETECTION_RULESET_GIT_REFERENCE: "@group_[group_id]_bot_[random_number]:$SECRET_DETECTION_GROUP_TOKEN@gitlab.com/example_group/secret-detection/secret-detection-custom-ruleset"
SECRET_DETECTION_HISTORIC_SCAN: 'true'
skip_ci:
allowed: true
allowlist:
users: []
approval_policy: []
```
## How It Works
Once the policy is running. all the projects associated with the global policy will have the `secret detect` job will run automatically in the pipeline as `secret_detection_0` job.
Secrets will be detected and surfaced. If there is a merge request, the net new secrets will be displayed in the MR widget. If it is the default branch merged, they will be shown in the security vulnerability report as following:
The following is an example password in clear text:
## Troubleshooting
### Policy not applying
Ensure the security policy project you modified is correctly linked to your group. See [Link to a security policy project](../../user/application_security/policies/enforcement/security_policy_projects.md#link-to-a-security-policy-project) for more.
|
https://docs.gitlab.com/solutions/oss_license_check
|
https://gitlab.com/gitlab-org/gitlab/-/tree/master/doc/solutions/oss_license_check.md
|
2025-08-13
|
doc/solutions/components
|
[
"doc",
"solutions",
"components"
] |
oss_license_check.md
|
Solutions Architecture
|
Solutions Architecture
|
This page is owned by the Solutions Architecture team.
|
OSS License Check
| null |
{{< details >}}
- Tier: Ultimate
- Offering: GitLab.com, GitLab Self-Managed, GitLab Dedicated
{{< /details >}}
## Getting Started
### Download the Solution Component
1. Obtain the invitation code from your account team.
1. Download the solution component from [the solution component webstore](https://cloud.gitlab-accelerator-marketplace.com) by using your invitation code.
## OSS Library License Check - GitLab Policy
This guide helps you implement a License Compliance Policy for your projects based on the Blue Oak Council license ratings. The policy will automatically require approval for any dependencies using licenses not included in the Blue Oak Council's Gold, Silver, and Bronze tiers.
You can also [keep your license list up to date](#keeping-your-license-list-up-to-date) with the provided Python script `update_licenses.py` that fetches the latest approved licenses.
## Overview
The OSS Library License Check provides:
- Automated license scanning for all dependencies in your projects
- Pre-configured policy to allow licenses rated [Gold](https://blueoakcouncil.org/list#gold), [Silver](https://blueoakcouncil.org/list#silver), and [Bronze](https://blueoakcouncil.org/list#bronze) by the Blue Oak Council
- Approval workflow for any licenses not in these tiers
## Prerequisites
- GitLab Ultimate tier
- Administrator access to your GitLab instance or group
- [Dependency scanning](../../user/application_security/dependency_scanning/_index.md) enabled for your projects (this can optionally be enabled and enforced for all projects of a specified scope by following the [Dependency Scanning Setup](#setting-up-dependency-scanning-from-scratch) instructions)
## Implementation Guide
This guide covers two main scenarios:
1. [Setting up from scratch](#setting-up-from-scratch-using-the-ui) (no existing security policy project)
- [Setting up Dependency Scanning](#setting-up-dependency-scanning-from-scratch)
- [Setting up License Compliance](#setting-up-license-compliance-from-scratch)
1. [Adding to an existing policy](#adding-to-an-existing-policy) (existing security policy project)
### Setting up from scratch (using the UI)
If you don't have a security policy project yet, you'll need to create one and then set up both dependency scanning and license compliance policies.
#### Setting up Dependency Scanning from scratch
1. First, identify which group you want to apply this policy to. This will be the highest group level where the policy can be applied (you can include or exclude projects within this group).
1. Navigate to that group's **Secure > Policies** page.
1. Click on **New policy**.
1. Select **Scan execution policy**.
1. Enter a name for your policy (for example, "Dependency Scanning Policy").
1. Enter a description (for example, "Enforces dependency scanning to get a list of OSS licenses used").
1. Set the **Policy scope** by selecting either "All projects in this group" (and optionally set exceptions) or "Specific projects" (and select the projects from the dropdown).
1. Under the **Actions** section, select "Dependency scanning" instead of "Secret Detection" (default).
1. Under the **Conditions** section, you can optionally change "Triggers:" to "Schedules:" if you want to run the scan on a schedule instead of at every commit.
1. Click **Create policy**.
#### Setting up License Compliance from scratch
After setting up dependency scanning, follow these steps to set up the license compliance policy:
1. Navigate back to the same group's **Secure > Policies** page.
1. Click on **New policy**.
1. Select **Merge request approval policy**.
1. Enter a name for your policy (for example, "OSS Compliance Policy").
1. Enter a description (for example, "Block any licenses that are not included in the Blue Oak Council's Gold, Silver, or Bronze tiers").
1. Set the **Policy scope** by selecting either "All projects in this group" (and optionally set exceptions) or "Specific projects" (and select the projects from the dropdown).
1. Under the **Rules** section, click the "Select scan type" dropdown and select **License Scan**.
1. Set the target branches (default is all protected branches).
1. Change the "Status is:" dropdown to **Newly detected** or **Pre-existing** (depending on whether you want to enforce the policy only on new dependencies or also on existing ones).
1. **IMPORTANT**: Change the "License is:" dropdown from the default "Matching" to **Except** (this ensures the policy works correctly to block non-approved licenses).
1. Scroll down to the **Actions** section and set the number of required approvals.
1. On the "Choose approver type" dropdown, select the users, groups, or roles that should provide approval (you can add multiple approver types in the same rule by clicking "Add new approver").
1. Configure the "Override project approval settings" section and change the default settings as needed.
1. Scroll back to the top of the page and click `.yaml mode`.
1. In the YAML editor, locate the `license_types` section and replace it with the complete list of approved licenses from the [Complete Policy Configuration](#complete-policy-configuration) section. The section will look something like this:
```yaml
rules:
- type: license_finding
match_on_inclusion_license: false
license_types:
# Replace this section with the full list of licenses from the Complete Policy Configuration section
- MIT License
- Apache License 2.0
# etc...
```
1. Click **Create policy**.
### Adding to an existing policy
If you already have a security policy project but don't have dependency and/or license compliance policies:
1. Navigate to your group's Security policy project.
1. Navigate to the `policy.yml` file in `.gitlab/security-policies/`.
1. Click on **Edit** > **Edit single file**.
1. Add the `scan_execution_policy` and `approval_policy` sections from [Complete Policy Configuration](#complete-policy-configuration).
1. Make sure to:
- Maintain the existing YAML structure
- Place these sections at the same level as other top-level sections
- Set `user_approvers_ids` and/or `group_approvers_ids` and/or `role_approvers` (only one is needed)
- Replace `YOUR_USER_ID_HERE` or `YOUR_GROUP_ID_HERE` with appropriate user/group IDs (ensure you paste the user/group IDs, for example, 1234567 and NOT the usernames)
- Replace `YOUR_PROJECT_ID_HERE` if you'd like to exclude any projects from the policy (ensure you paste the project IDs, for example, 1234 and NOT the project names/paths)
- Set `approvals_required: 1` to the number of approvals you want to require
- Modify the `approval_settings` section as needed (anything set to `true` will override project approval settings)
1. Click **Commit changes**, and commit to a new branch. Select **Create a merge request for this change** so that the policy change can be merged.
## Complete Policy Configuration
For reference, here is the complete policy configuration:
```yaml
scan_execution_policy:
- name: License scan policy
description: Enforces dependency scanning to get a list of OSS licenses used, in
order to remain compliant with OSS usage guidance.
enabled: true
policy_scope:
projects:
excluding:
- id: YOUR_PROJECT_ID_HERE
- id: YOUR_PROJECT_ID_HERE
rules:
- type: pipeline
branch_type: all
actions:
- scan: dependency_scanning
skip_ci:
allowed: true
allowlist:
users: []
approval_policy:
- name: OSS Compliance Policy
description: |-
Block any licenses that are not included in the Blue Oak Council's Gold, Silver, or Bronze tiers.
https://blueoakcouncil.org/list
enabled: true
policy_scope:
projects:
excluding:
- id: YOUR_PROJECT_ID_HERE
- id: YOUR_PROJECT_ID_HERE
rules:
- type: license_finding
match_on_inclusion_license: false
license_types:
- BSD-2-Clause Plus Patent License
- Amazon Digital Services License
- Apache License 2.0
- Adobe Postscript AFM License
- BSD 1-Clause License
- BSD 2-Clause "Simplified" License
- BSD 2-Clause FreeBSD License
- BSD 2-Clause NetBSD License
- BSD 2-Clause with Views Sentence
- Boost Software License 1.0
- DSDP License
- Educational Community License v1.0
- Educational Community License v2.0
- hdparm License
- ImageMagick License
- Intel ACPI Software License Agreement
- ISC License
- Linux Kernel Variant of OpenIB.org license
- MIT License
- MIT License Modern Variant
- MIT testregex Variant
- MIT Tom Wu Variant
- Microsoft Public License
- Mulan Permissive Software License, Version 1
- Mup License
- PostgreSQL License
- Solderpad Hardware License v0.5
- Spencer License 99
- Universal Permissive License v1.0
- Xerox License
- Xfig License
- BSD Zero Clause License
- Academic Free License v1.1
- Academic Free License v1.2
- Academic Free License v2.0
- Academic Free License v2.1
- Academic Free License v3.0
- AMD's plpa_map.c License
- Apple MIT License
- Academy of Motion Picture Arts and Sciences BSD
- ANTLR Software Rights Notice
- ANTLR Software Rights Notice with license fallback
- Apache License 1.0
- Apache License 1.1
- Artistic License 2.0
- Bahyph License
- Barr License
- bcrypt Solar Designer License
- BSD 3-Clause "New" or "Revised" License
- BSD with attribution
- BSD 3-Clause Clear License
- Hewlett-Packard BSD variant license
- Lawrence Berkeley National Labs BSD variant license
- BSD 3-Clause Modification
- BSD 3-Clause No Nuclear License 2014
- BSD 3-Clause No Nuclear Warranty
- BSD 3-Clause Open MPI Variant
- BSD 3-Clause Sun Microsystems
- BSD 4-Clause "Original" or "Old" License
- BSD 4-Clause Shortened
- BSD-4-Clause (University of California-Specific)
- BSD Source Code Attribution
- bzip2 and libbzip2 License v1.0.5
- bzip2 and libbzip2 License v1.0.6
- Creative Commons Zero v1.0 Universal
- CFITSIO License
- Clips License
- CNRI Jython License
- CNRI Python License
- CNRI Python Open Source GPL Compatible License Agreement
- Cube License
- curl License
- eGenix.com Public License 1.1.0
- Entessa Public License v1.0
- Freetype Project License
- fwlw License
- Historical Permission Notice and Disclaimer - Fenneberg-Livingston variant
- Historical Permission Notice and Disclaimer - sell regexpr variant
- HTML Tidy License
- IBM PowerPC Initialization and Boot Software
- ICU License
- Info-ZIP License
- Intel Open Source License
- JasPer License
- libpng License
- PNG Reference Library version 2
- libtiff License
- LaTeX Project Public License v1.3c
- LZMA SDK License (versions 9.22 and beyond)
- MIT No Attribution
- Enlightenment License (e16)
- CMU License
- enna License
- feh License
- MIT Open Group Variant
- MIT +no-false-attribs license
- Matrix Template Library License
- Mulan Permissive Software License, Version 2
- Multics License
- Naumen Public License
- University of Illinois/NCSA Open Source License
- Net-SNMP License
- NetCDF license
- NICTA Public Software License, Version 1.0
- NIST Software License
- NTP License
- Open Government Licence - Canada
- Open LDAP Public License v2.0 (or possibly 2.0A and 2.0B)
- Open LDAP Public License v2.0.1
- Open LDAP Public License v2.1
- Open LDAP Public License v2.2
- Open LDAP Public License v2.2.1
- Open LDAP Public License 2.2.2
- Open LDAP Public License v2.3
- Open LDAP Public License v2.4
- Open LDAP Public License v2.5
- Open LDAP Public License v2.6
- Open LDAP Public License v2.7
- Open LDAP Public License v2.8
- Open Market License
- OpenSSL License
- PHP License v3.0
- PHP License v3.01
- Plexus Classworlds License
- Python Software Foundation License 2.0
- Python License 2.0
- Ruby License
- Saxpath License
- SGI Free Software License B v2.0
- Standard ML of New Jersey License
- SunPro License
- Scheme Widget Library (SWL) Software License Agreement
- Symlinks License
- TCL/TK License
- TCP Wrappers License
- UCAR License
- Unicode License Agreement - Data Files and Software (2015)
- Unicode License Agreement - Data Files and Software (2016)
- UnixCrypt License
- The Unlicense
- Vovida Software License v1.0
- W3C Software Notice and License (2002-12-31)
- X11 License
- XFree86 License 1.1
- xlock License
- X.Net License
- XPP License
- zlib License
- zlib/libpng License with Acknowledgment
- Zope Public License 2.0
- Zope Public License 2.1
license_states:
- newly_detected
branch_type: default
actions:
- type: require_approval
approvals_required: 1
user_approvers_ids:
# Replace with the user IDs of your compliance approver(s)
- YOUR_USER_ID_HERE
- YOUR_USER_ID_HERE
group_approvers_ids:
# Replace with the group IDs of your compliance approver(s)
- YOUR_GROUP_ID_HERE
- YOUR_GROUP_ID_HERE
role_approvers:
# Replace with the roles of your compliance approver(s)
- owner
- maintainer
- type: send_bot_message
enabled: true
approval_settings:
block_branch_modification: true
block_group_branch_modification: true
prevent_pushing_and_force_pushing: true
prevent_approval_by_author: true
prevent_approval_by_commit_author: true
remove_approvals_with_new_commit: true
require_password_to_approve: false
fallback_behavior:
fail: closed
```
## How It Works
1. The `scan_execution_policy` section configures GitLab to run dependency scanning on all branches, which generates a CycloneDX format SBOM file that is used by the license approval policy.
1. The `approval_policy` section creates a rule that:
- Contains a list of pre-approved licenses ([Gold](https://blueoakcouncil.org/list#gold), [Silver](https://blueoakcouncil.org/list#silver), and [Bronze](https://blueoakcouncil.org/list#bronze) tiers from Blue Oak Council)
- Requires approval for any license not in this list
- Sends a bot message when a non-approved license is detected
- Blocks merging until approval is granted
## Customization Options
- **Approvers**: You can specify approvers in three ways:
- `user_approvers_ids`: Replace with the user IDs of individuals who should approve licenses (for example, `1234567`)
- `group_approvers_ids`: Replace with the group IDs that contain approvers (for example, `9876543`)
- `role_approvers`: Specify roles that can approve, options are `developer`, `maintainer`, or `owner`
- **Project Exclusions**: Add project IDs to the `policy_scope.projects.excluding` section to exempt them from the policy
- **Required approvals**: Change `approvals_required: 1` to require more approvals
- **Bot messages**: Set `enabled: false` under `send_bot_message` to disable bot notifications
- **Override project approval settings**: Modify the `approval_settings` section as needed (anything set to `true` will override project settings)
## Keeping Your License List Up to Date
To ensure your list of approved licenses stays current with the Blue Oak Council ratings, you can use the following Python script to fetch the latest license data:
```python
import requests
def fetch_license_data():
url = "https://blueoakcouncil.org/list.json"
try:
response = requests.get(url)
response.raise_for_status() # Raise an exception for bad status codes
return response.json()
except requests.RequestException as e:
print(f"Error fetching data: {e}")
return None
# Fetch and print the data to verify it worked
data = fetch_license_data()
if data:
# Look through each rating section
target_tiers = ['Gold', 'Silver', 'Bronze']
for rating in data['ratings']:
if rating['name'] in target_tiers:
# Print each license name in this tier
for license in rating['licenses']:
print(f"- {license['name']}")
```
To use this script:
1. Save it as `update_licenses.py`.
1. Install the requests library if you haven't already: `pip install requests`.
1. Run the script: `python update_licenses.py`.
1. Copy the output (list of licenses) and replace the existing `license_types` list in your `policy.yml` file.
This ensures your policy always reflects the most current Blue Oak Council license ratings.
## Troubleshooting
### Policy not applying
Ensure the security policy project you modified is correctly linked to your group. See [Link to a security policy project](../../user/application_security/policies/enforcement/security_policy_projects.md#link-to-a-security-policy-project) for more.
### Dependency scan not running
Check that dependency scanning is enabled in your CI/CD configuration, and there is a dependency file present. See [Troubleshooting Dependency Scanning](../../user/application_security/dependency_scanning/troubleshooting_dependency_scanning.md) for more.
## Additional Resources
- [Blue Oak Council License List](https://blueoakcouncil.org/list)
- [GitLab License Compliance Documentation](../../user/compliance/license_scanning_of_cyclonedx_files/_index.md)
- [GitLab Merge Request Approval Policies](../../user/compliance/license_approval_policies.md)
- [GitLab Dependency Scanning](../../user/application_security/dependency_scanning/_index.md)
|
---
stage: Solutions Architecture
group: Solutions Architecture
info: This page is owned by the Solutions Architecture team.
title: OSS License Check
breadcrumbs:
- doc
- solutions
- components
---
{{< details >}}
- Tier: Ultimate
- Offering: GitLab.com, GitLab Self-Managed, GitLab Dedicated
{{< /details >}}
## Getting Started
### Download the Solution Component
1. Obtain the invitation code from your account team.
1. Download the solution component from [the solution component webstore](https://cloud.gitlab-accelerator-marketplace.com) by using your invitation code.
## OSS Library License Check - GitLab Policy
This guide helps you implement a License Compliance Policy for your projects based on the Blue Oak Council license ratings. The policy will automatically require approval for any dependencies using licenses not included in the Blue Oak Council's Gold, Silver, and Bronze tiers.
You can also [keep your license list up to date](#keeping-your-license-list-up-to-date) with the provided Python script `update_licenses.py` that fetches the latest approved licenses.
## Overview
The OSS Library License Check provides:
- Automated license scanning for all dependencies in your projects
- Pre-configured policy to allow licenses rated [Gold](https://blueoakcouncil.org/list#gold), [Silver](https://blueoakcouncil.org/list#silver), and [Bronze](https://blueoakcouncil.org/list#bronze) by the Blue Oak Council
- Approval workflow for any licenses not in these tiers
## Prerequisites
- GitLab Ultimate tier
- Administrator access to your GitLab instance or group
- [Dependency scanning](../../user/application_security/dependency_scanning/_index.md) enabled for your projects (this can optionally be enabled and enforced for all projects of a specified scope by following the [Dependency Scanning Setup](#setting-up-dependency-scanning-from-scratch) instructions)
## Implementation Guide
This guide covers two main scenarios:
1. [Setting up from scratch](#setting-up-from-scratch-using-the-ui) (no existing security policy project)
- [Setting up Dependency Scanning](#setting-up-dependency-scanning-from-scratch)
- [Setting up License Compliance](#setting-up-license-compliance-from-scratch)
1. [Adding to an existing policy](#adding-to-an-existing-policy) (existing security policy project)
### Setting up from scratch (using the UI)
If you don't have a security policy project yet, you'll need to create one and then set up both dependency scanning and license compliance policies.
#### Setting up Dependency Scanning from scratch
1. First, identify which group you want to apply this policy to. This will be the highest group level where the policy can be applied (you can include or exclude projects within this group).
1. Navigate to that group's **Secure > Policies** page.
1. Click on **New policy**.
1. Select **Scan execution policy**.
1. Enter a name for your policy (for example, "Dependency Scanning Policy").
1. Enter a description (for example, "Enforces dependency scanning to get a list of OSS licenses used").
1. Set the **Policy scope** by selecting either "All projects in this group" (and optionally set exceptions) or "Specific projects" (and select the projects from the dropdown).
1. Under the **Actions** section, select "Dependency scanning" instead of "Secret Detection" (default).
1. Under the **Conditions** section, you can optionally change "Triggers:" to "Schedules:" if you want to run the scan on a schedule instead of at every commit.
1. Click **Create policy**.
#### Setting up License Compliance from scratch
After setting up dependency scanning, follow these steps to set up the license compliance policy:
1. Navigate back to the same group's **Secure > Policies** page.
1. Click on **New policy**.
1. Select **Merge request approval policy**.
1. Enter a name for your policy (for example, "OSS Compliance Policy").
1. Enter a description (for example, "Block any licenses that are not included in the Blue Oak Council's Gold, Silver, or Bronze tiers").
1. Set the **Policy scope** by selecting either "All projects in this group" (and optionally set exceptions) or "Specific projects" (and select the projects from the dropdown).
1. Under the **Rules** section, click the "Select scan type" dropdown and select **License Scan**.
1. Set the target branches (default is all protected branches).
1. Change the "Status is:" dropdown to **Newly detected** or **Pre-existing** (depending on whether you want to enforce the policy only on new dependencies or also on existing ones).
1. **IMPORTANT**: Change the "License is:" dropdown from the default "Matching" to **Except** (this ensures the policy works correctly to block non-approved licenses).
1. Scroll down to the **Actions** section and set the number of required approvals.
1. On the "Choose approver type" dropdown, select the users, groups, or roles that should provide approval (you can add multiple approver types in the same rule by clicking "Add new approver").
1. Configure the "Override project approval settings" section and change the default settings as needed.
1. Scroll back to the top of the page and click `.yaml mode`.
1. In the YAML editor, locate the `license_types` section and replace it with the complete list of approved licenses from the [Complete Policy Configuration](#complete-policy-configuration) section. The section will look something like this:
```yaml
rules:
- type: license_finding
match_on_inclusion_license: false
license_types:
# Replace this section with the full list of licenses from the Complete Policy Configuration section
- MIT License
- Apache License 2.0
# etc...
```
1. Click **Create policy**.
### Adding to an existing policy
If you already have a security policy project but don't have dependency and/or license compliance policies:
1. Navigate to your group's Security policy project.
1. Navigate to the `policy.yml` file in `.gitlab/security-policies/`.
1. Click on **Edit** > **Edit single file**.
1. Add the `scan_execution_policy` and `approval_policy` sections from [Complete Policy Configuration](#complete-policy-configuration).
1. Make sure to:
- Maintain the existing YAML structure
- Place these sections at the same level as other top-level sections
- Set `user_approvers_ids` and/or `group_approvers_ids` and/or `role_approvers` (only one is needed)
- Replace `YOUR_USER_ID_HERE` or `YOUR_GROUP_ID_HERE` with appropriate user/group IDs (ensure you paste the user/group IDs, for example, 1234567 and NOT the usernames)
- Replace `YOUR_PROJECT_ID_HERE` if you'd like to exclude any projects from the policy (ensure you paste the project IDs, for example, 1234 and NOT the project names/paths)
- Set `approvals_required: 1` to the number of approvals you want to require
- Modify the `approval_settings` section as needed (anything set to `true` will override project approval settings)
1. Click **Commit changes**, and commit to a new branch. Select **Create a merge request for this change** so that the policy change can be merged.
## Complete Policy Configuration
For reference, here is the complete policy configuration:
```yaml
scan_execution_policy:
- name: License scan policy
description: Enforces dependency scanning to get a list of OSS licenses used, in
order to remain compliant with OSS usage guidance.
enabled: true
policy_scope:
projects:
excluding:
- id: YOUR_PROJECT_ID_HERE
- id: YOUR_PROJECT_ID_HERE
rules:
- type: pipeline
branch_type: all
actions:
- scan: dependency_scanning
skip_ci:
allowed: true
allowlist:
users: []
approval_policy:
- name: OSS Compliance Policy
description: |-
Block any licenses that are not included in the Blue Oak Council's Gold, Silver, or Bronze tiers.
https://blueoakcouncil.org/list
enabled: true
policy_scope:
projects:
excluding:
- id: YOUR_PROJECT_ID_HERE
- id: YOUR_PROJECT_ID_HERE
rules:
- type: license_finding
match_on_inclusion_license: false
license_types:
- BSD-2-Clause Plus Patent License
- Amazon Digital Services License
- Apache License 2.0
- Adobe Postscript AFM License
- BSD 1-Clause License
- BSD 2-Clause "Simplified" License
- BSD 2-Clause FreeBSD License
- BSD 2-Clause NetBSD License
- BSD 2-Clause with Views Sentence
- Boost Software License 1.0
- DSDP License
- Educational Community License v1.0
- Educational Community License v2.0
- hdparm License
- ImageMagick License
- Intel ACPI Software License Agreement
- ISC License
- Linux Kernel Variant of OpenIB.org license
- MIT License
- MIT License Modern Variant
- MIT testregex Variant
- MIT Tom Wu Variant
- Microsoft Public License
- Mulan Permissive Software License, Version 1
- Mup License
- PostgreSQL License
- Solderpad Hardware License v0.5
- Spencer License 99
- Universal Permissive License v1.0
- Xerox License
- Xfig License
- BSD Zero Clause License
- Academic Free License v1.1
- Academic Free License v1.2
- Academic Free License v2.0
- Academic Free License v2.1
- Academic Free License v3.0
- AMD's plpa_map.c License
- Apple MIT License
- Academy of Motion Picture Arts and Sciences BSD
- ANTLR Software Rights Notice
- ANTLR Software Rights Notice with license fallback
- Apache License 1.0
- Apache License 1.1
- Artistic License 2.0
- Bahyph License
- Barr License
- bcrypt Solar Designer License
- BSD 3-Clause "New" or "Revised" License
- BSD with attribution
- BSD 3-Clause Clear License
- Hewlett-Packard BSD variant license
- Lawrence Berkeley National Labs BSD variant license
- BSD 3-Clause Modification
- BSD 3-Clause No Nuclear License 2014
- BSD 3-Clause No Nuclear Warranty
- BSD 3-Clause Open MPI Variant
- BSD 3-Clause Sun Microsystems
- BSD 4-Clause "Original" or "Old" License
- BSD 4-Clause Shortened
- BSD-4-Clause (University of California-Specific)
- BSD Source Code Attribution
- bzip2 and libbzip2 License v1.0.5
- bzip2 and libbzip2 License v1.0.6
- Creative Commons Zero v1.0 Universal
- CFITSIO License
- Clips License
- CNRI Jython License
- CNRI Python License
- CNRI Python Open Source GPL Compatible License Agreement
- Cube License
- curl License
- eGenix.com Public License 1.1.0
- Entessa Public License v1.0
- Freetype Project License
- fwlw License
- Historical Permission Notice and Disclaimer - Fenneberg-Livingston variant
- Historical Permission Notice and Disclaimer - sell regexpr variant
- HTML Tidy License
- IBM PowerPC Initialization and Boot Software
- ICU License
- Info-ZIP License
- Intel Open Source License
- JasPer License
- libpng License
- PNG Reference Library version 2
- libtiff License
- LaTeX Project Public License v1.3c
- LZMA SDK License (versions 9.22 and beyond)
- MIT No Attribution
- Enlightenment License (e16)
- CMU License
- enna License
- feh License
- MIT Open Group Variant
- MIT +no-false-attribs license
- Matrix Template Library License
- Mulan Permissive Software License, Version 2
- Multics License
- Naumen Public License
- University of Illinois/NCSA Open Source License
- Net-SNMP License
- NetCDF license
- NICTA Public Software License, Version 1.0
- NIST Software License
- NTP License
- Open Government Licence - Canada
- Open LDAP Public License v2.0 (or possibly 2.0A and 2.0B)
- Open LDAP Public License v2.0.1
- Open LDAP Public License v2.1
- Open LDAP Public License v2.2
- Open LDAP Public License v2.2.1
- Open LDAP Public License 2.2.2
- Open LDAP Public License v2.3
- Open LDAP Public License v2.4
- Open LDAP Public License v2.5
- Open LDAP Public License v2.6
- Open LDAP Public License v2.7
- Open LDAP Public License v2.8
- Open Market License
- OpenSSL License
- PHP License v3.0
- PHP License v3.01
- Plexus Classworlds License
- Python Software Foundation License 2.0
- Python License 2.0
- Ruby License
- Saxpath License
- SGI Free Software License B v2.0
- Standard ML of New Jersey License
- SunPro License
- Scheme Widget Library (SWL) Software License Agreement
- Symlinks License
- TCL/TK License
- TCP Wrappers License
- UCAR License
- Unicode License Agreement - Data Files and Software (2015)
- Unicode License Agreement - Data Files and Software (2016)
- UnixCrypt License
- The Unlicense
- Vovida Software License v1.0
- W3C Software Notice and License (2002-12-31)
- X11 License
- XFree86 License 1.1
- xlock License
- X.Net License
- XPP License
- zlib License
- zlib/libpng License with Acknowledgment
- Zope Public License 2.0
- Zope Public License 2.1
license_states:
- newly_detected
branch_type: default
actions:
- type: require_approval
approvals_required: 1
user_approvers_ids:
# Replace with the user IDs of your compliance approver(s)
- YOUR_USER_ID_HERE
- YOUR_USER_ID_HERE
group_approvers_ids:
# Replace with the group IDs of your compliance approver(s)
- YOUR_GROUP_ID_HERE
- YOUR_GROUP_ID_HERE
role_approvers:
# Replace with the roles of your compliance approver(s)
- owner
- maintainer
- type: send_bot_message
enabled: true
approval_settings:
block_branch_modification: true
block_group_branch_modification: true
prevent_pushing_and_force_pushing: true
prevent_approval_by_author: true
prevent_approval_by_commit_author: true
remove_approvals_with_new_commit: true
require_password_to_approve: false
fallback_behavior:
fail: closed
```
## How It Works
1. The `scan_execution_policy` section configures GitLab to run dependency scanning on all branches, which generates a CycloneDX format SBOM file that is used by the license approval policy.
1. The `approval_policy` section creates a rule that:
- Contains a list of pre-approved licenses ([Gold](https://blueoakcouncil.org/list#gold), [Silver](https://blueoakcouncil.org/list#silver), and [Bronze](https://blueoakcouncil.org/list#bronze) tiers from Blue Oak Council)
- Requires approval for any license not in this list
- Sends a bot message when a non-approved license is detected
- Blocks merging until approval is granted
## Customization Options
- **Approvers**: You can specify approvers in three ways:
- `user_approvers_ids`: Replace with the user IDs of individuals who should approve licenses (for example, `1234567`)
- `group_approvers_ids`: Replace with the group IDs that contain approvers (for example, `9876543`)
- `role_approvers`: Specify roles that can approve, options are `developer`, `maintainer`, or `owner`
- **Project Exclusions**: Add project IDs to the `policy_scope.projects.excluding` section to exempt them from the policy
- **Required approvals**: Change `approvals_required: 1` to require more approvals
- **Bot messages**: Set `enabled: false` under `send_bot_message` to disable bot notifications
- **Override project approval settings**: Modify the `approval_settings` section as needed (anything set to `true` will override project settings)
## Keeping Your License List Up to Date
To ensure your list of approved licenses stays current with the Blue Oak Council ratings, you can use the following Python script to fetch the latest license data:
```python
import requests
def fetch_license_data():
url = "https://blueoakcouncil.org/list.json"
try:
response = requests.get(url)
response.raise_for_status() # Raise an exception for bad status codes
return response.json()
except requests.RequestException as e:
print(f"Error fetching data: {e}")
return None
# Fetch and print the data to verify it worked
data = fetch_license_data()
if data:
# Look through each rating section
target_tiers = ['Gold', 'Silver', 'Bronze']
for rating in data['ratings']:
if rating['name'] in target_tiers:
# Print each license name in this tier
for license in rating['licenses']:
print(f"- {license['name']}")
```
To use this script:
1. Save it as `update_licenses.py`.
1. Install the requests library if you haven't already: `pip install requests`.
1. Run the script: `python update_licenses.py`.
1. Copy the output (list of licenses) and replace the existing `license_types` list in your `policy.yml` file.
This ensures your policy always reflects the most current Blue Oak Council license ratings.
## Troubleshooting
### Policy not applying
Ensure the security policy project you modified is correctly linked to your group. See [Link to a security policy project](../../user/application_security/policies/enforcement/security_policy_projects.md#link-to-a-security-policy-project) for more.
### Dependency scan not running
Check that dependency scanning is enabled in your CI/CD configuration, and there is a dependency file present. See [Troubleshooting Dependency Scanning](../../user/application_security/dependency_scanning/troubleshooting_dependency_scanning.md) for more.
## Additional Resources
- [Blue Oak Council License List](https://blueoakcouncil.org/list)
- [GitLab License Compliance Documentation](../../user/compliance/license_scanning_of_cyclonedx_files/_index.md)
- [GitLab Merge Request Approval Policies](../../user/compliance/license_approval_policies.md)
- [GitLab Dependency Scanning](../../user/application_security/dependency_scanning/_index.md)
|
https://docs.gitlab.com/solutions/duo_workflow_codestyle
|
https://gitlab.com/gitlab-org/gitlab/-/tree/master/doc/solutions/duo_workflow_codestyle.md
|
2025-08-13
|
doc/solutions/components
|
[
"doc",
"solutions",
"components"
] |
duo_workflow_codestyle.md
| null | null | null | null | null |
<!-- markdownlint-disable -->
This document was moved to [another location](duo_workflow/duo_workflow_codestyle.md).
<!-- This redirect file can be deleted after <2025-08-15>. -->
<!-- Redirects that point to other docs in the same project expire in three months. -->
<!-- Redirects that point to docs in a different project or site (for example, link is not relative and starts with `https:`) expire in one year. -->
<!-- Before deletion, see: https://docs.gitlab.com/development/documentation/redirects -->
|
---
redirect_to: duo_workflow/duo_workflow_codestyle.md
remove_date: '2025-08-15'
breadcrumbs:
- doc
- solutions
- components
---
<!-- markdownlint-disable -->
This document was moved to [another location](duo_workflow/duo_workflow_codestyle.md).
<!-- This redirect file can be deleted after <2025-08-15>. -->
<!-- Redirects that point to other docs in the same project expire in three months. -->
<!-- Redirects that point to docs in a different project or site (for example, link is not relative and starts with `https:`) expire in one year. -->
<!-- Before deletion, see: https://docs.gitlab.com/development/documentation/redirects -->
|
https://docs.gitlab.com/solutions/ai_gatewaysolution
|
https://gitlab.com/gitlab-org/gitlab/-/tree/master/doc/solutions/ai_gatewaysolution.md
|
2025-08-13
|
doc/solutions/components
|
[
"doc",
"solutions",
"components"
] |
ai_gatewaysolution.md
|
Solutions Architecture
|
Solutions Architecture
|
This page is owned by the Solutions Architecture team.
|
AI Gateway Solution
| null |
{{< details >}}
- Tier: Ultimate
- Add-on: GitLab Duo Pro or Enterprise
- Offering: GitLab Self-Managed
{{< /details >}}
The document describes the installation package and integration scripts of GitLab and GitLab Duo with a self-hosted Large Language Model (LLM) running a selected models on Ollama.
<!--
Note: This page has been removed from the Global Navigation as it does not contain any content.
When the content is added, you can remove `ignore_in_report: true` from the frontmatter
at the top of the page. Then add it back to the navigation: https://docs.gitlab.com/development/documentation/site_architecture/global_nav/#add-a-navigation-entry
-->
|
---
stage: Solutions Architecture
group: Solutions Architecture
info: This page is owned by the Solutions Architecture team.
ignore_in_report: true
title: AI Gateway Solution
breadcrumbs:
- doc
- solutions
- components
---
{{< details >}}
- Tier: Ultimate
- Add-on: GitLab Duo Pro or Enterprise
- Offering: GitLab Self-Managed
{{< /details >}}
The document describes the installation package and integration scripts of GitLab and GitLab Duo with a self-hosted Large Language Model (LLM) running a selected models on Ollama.
<!--
Note: This page has been removed from the Global Navigation as it does not contain any content.
When the content is added, you can remove `ignore_in_report: true` from the frontmatter
at the top of the page. Then add it back to the navigation: https://docs.gitlab.com/development/documentation/site_architecture/global_nav/#add-a-navigation-entry
-->
|
https://docs.gitlab.com/solutions/jira_vsa
|
https://gitlab.com/gitlab-org/gitlab/-/tree/master/doc/solutions/jira_vsa.md
|
2025-08-13
|
doc/solutions/components
|
[
"doc",
"solutions",
"components"
] |
jira_vsa.md
|
Solutions Architecture
|
Solutions Architecture
|
This page is owned by the Solutions Architecture team.
|
Jira to GitLab VSA Integration
| null |
{{< details >}}
- Tier: Premium, Ultimate
- Offering: GitLab.com, GitLab Self-Managed, GitLab Dedicated
{{< /details >}}
GitLab [Value Stream Analytics (VSA)](../../user/group/value_stream_analytics/_index.md) provides powerful insights into your development workflow, tracking key metrics such as:
- **Lead time**: Time from issue creation to completion
- **Issues created**: Number of new issues in a given time period
- **Issues closed**: Number of resolved issues in a given time period
For teams using Jira for issue tracking while leveraging GitLab for development, this integration enables automatic replication of Jira issues to GitLab in real-time. This ensures accurate VSA metrics without requiring teams to change their existing Jira workflows.
The integration also populates the GitLab **Value Streams Dashboard** (Ultimate only), which provides an overview of key DevSecOps metrics and can be found under **Analyze > Analytics dashboards** in your GitLab project or group.
**NOTE**: A similar integration exists for incident replication to generate specific DORA metrics (Change Failure Rate and Time to Restore Service). If you're interested in incident replication, refer to the [Jira Incident Replicator](jira_dora.md).
## Architecture
We will create 2 automation workflows using Jira automation:
1. Create GitLab issues when they are created in Jira
1. Close GitLab issues when they are resolved in Jira
### Issue Creation
When a new issue is created in Jira, the automation workflow sends a POST request to the GitLab Issues API to create a corresponding issue in the specified GitLab project.
### Issue Resolution
When a Jira issue transitions to a resolved state (Closed, Done, Resolved), the automation workflow sends a PUT request to close the corresponding GitLab issue.
## Setup
### Pre-requisites
This walkthrough assumes that you have:
- A GitLab project where you want VSA analytics to be generated
- A Jira project to replicate issues from
- GitLab Ultimate or Premium license (for Value Stream Analytics features)
Jira places [limits](https://www.atlassian.com/software/jira/pricing) on the frequency of Automation runs depending on your Jira license:
| **Tier** | **Limit** |
|------------|------------------------------|
| Free | 100 runs per month |
| Standard | 1700 runs per month |
| Premium | 1000 runs per user per month |
| Enterprise | Unlimited runs |
Each issue creation counts as 1 run, and each issue resolution counts as 1 run.
### GitLab Project Access Token
First, we need to create a GitLab project access token with the necessary permissions to create and update issues via the API.
1. Navigate to your GitLab project where you want Jira issues to be replicated. From the sidebar, go to **Settings > Access Tokens**.
1. Click **Add new token**.
1. Set the following configuration:
- **Token name**: `Jira VSA Integration` (or any descriptive name)
- **Expiration date**: Set according to your security policies
- **Role**: `Owner` (This is required to set custom issue IDs)
- **Scopes**: Check `api` (full API access)
**Important**: An **Owner** level access token is required because the integration needs to force-set custom issue IDs when creating issues in GitLab. This ensures that when Jira issues are closed, the automation can identify and close the corresponding GitLab issue using the same ID mapping. Without the Owner role, the GitLab API will not allow setting custom issue IDs, breaking the synchronization between Jira issue closure and GitLab issue closure.
1. Click **Create project access token** and save the generated token securely - you'll need it for the Jira automation setup.
### Jira Issue Creation Workflow
To automatically create GitLab issues when Jira issues are created, we'll use [Jira automation](https://community.atlassian.com/t5/Jira-articles/Automation-for-Jira-Send-web-request-using-Jira-REST-API/ba-p/1443828).
1. Navigate to your Jira project. From the sidebar, head to **Project settings > Automation**.
1. Click **Create rule** at the top-right.
1. For your trigger, search for and select **Issue created**. Click **Save**.
1. *Optional*: Add conditions to filter which issues should be replicated. For example, you might want to add an **Issue fields condition** to only replicate issues of certain types or with specific labels.
1. Select **THEN: Add an action**. Search for and select **Send web request**.
1. Configure the web request:
- **Web request URL**: `https://gitlab.com/api/v4/projects/<GITLAB_PROJECT_ID>/issues` (replace `gitlab.com` with your GitLab instance URL if self-hosted, and `<GITLAB_PROJECT_ID>` with your GitLab project's numerical ID, e.g., `42718690`)
- **HTTP method**: **POST**
- **Web request body**: **Custom data**
1. Add the following headers:
| Name | Value |
| ------ | ------ |
| Authorization | Bearer `<YOUR_GITLAB_TOKEN>` |
| Content-Type | `application/json` |
Set the Authorization header to "Hidden" for security.
1. In the **Custom data** field, enter:
```json
{
"title": "{{issue.summary}}",
"iid": {{issue.key.replace("VSA-", "1000")}}
}
```
Replace `"VSA-"` with your Jira project prefix (e.g., if your Jira issues are numbered `PROJ-123`, use `"PROJ-"`). The `1000` is a base number that gets added to ensure no conflict with issues that may have been created directly within GitLab itself via the UI - you can adjust this value as needed.
1. Click **Save**, give your automation a descriptive name (e.g., `Jira to GitLab Issue Creation`), and click **Turn it on**.
### Jira Issue Resolution Workflow
Create a second automation workflow to close GitLab issues when Jira issues are resolved:
1. Follow steps 1-2 from the creation workflow to start a new rule.
1. Set the trigger to **Issue transitioned**:
- Leave "From status" field blank
- Set "To status" to resolved statuses: `Closed`, `Done`, `Resolved` (adjust based on your Jira workflow)
1. Skip conditions (or add custom ones if needed).
1. Add a **Send web request** action with:
- **Web request URL**: `https://gitlab.com/api/v4/projects/<GITLAB_PROJECT_ID>/issues/{{issue.key.replace("<JIRA_PROJECT_PREFIX>-", "1000").urlEncode}}` (replace `gitlab.com` with your GitLab instance URL if self-hosted, `<GITLAB_PROJECT_ID>` with your GitLab project's numerical ID, and `<JIRA_PROJECT_PREFIX>` with your Jira project prefix like `VSA` or `PROJ`)
- **HTTP method**: **PUT**
- **Web request body**: **Custom data**
1. Use the same headers as the creation workflow.
1. In the **Custom data** field, enter:
```json
{
"state_event": "close"
}
```
1. Save and enable the automation rule with a descriptive name (e.g., `Jira to GitLab Issue Closer`).
## Value Stream Analytics Configuration
Once your automation workflows are active, GitLab will begin receiving issue data. Here's how to access your analytics:
### Value Streams Dashboard (Automatic - Ultimate Only)
The **Value Streams Dashboard** is automatically populated with metrics from your replicated issues and is available with GitLab Ultimate:
1. In your GitLab project or group, navigate to **Analyze > Analytics dashboards**
1. Click on **Value Streams Dashboard**
1. You'll see metrics including Issues created, Issues closed, Lead time, and Cycle time
### Value Stream Analytics (Requires Setup - Premium and Ultimate)
For more detailed analytics and custom value streams (available with GitLab Premium and Ultimate):
1. Navigate to **Analyze > Value stream analytics** in your GitLab project or group
1. Click **New value stream** to create a custom value stream
1. Configure stages and workflows according to your development process
1. Metrics like lead time and new issues count will be automatically generated and displayed next to the stages you create
1. Refer to the [GitLab Value Stream Analytics documentation](../../user/group/value_stream_analytics/_index.md#create-a-value-stream) for detailed setup instructions
## Multi-Project Considerations
If you want to replicate issues from multiple Jira projects using a single set of automation rules, consider using a timestamp-based approach for generating unique issue IDs instead of the project prefix method:
Replace the `iid` value in your custom data with:
```json
"iid": {{issue.created.replace("-","").replace("T","").replace(":","").replace(".","").replace("+","")}}
```
This converts the creation timestamp (format: `2025-02-15T09:45:32.7+0000`) into a numeric value. Note that this approach may result in very long issue IDs and has a small risk of conflicts if two issues are created at exactly the same time.
## Resources
- [GitLab Value Stream Analytics](../../user/group/value_stream_analytics/_index.md)
- [Create a Value Stream](../../user/group/value_stream_analytics/_index.md#create-a-value-stream)
- [GitLab Value Streams Dashboard](../../user/analytics/value_streams_dashboard.md)
- [GitLab Issues API](../../api/issues.md)
- [Create new issue](../../api/issues.md#new-issue)
- [Edit issue](../../api/issues.md#edit-an-issue)
- [GitLab Project Access Tokens](../../user/project/settings/project_access_tokens.md)
- [Jira automation with web requests](https://community.atlassian.com/t5/Jira-articles/Automation-for-Jira-Send-web-request-using-Jira-REST-API/ba-p/1443828)
|
---
stage: Solutions Architecture
group: Solutions Architecture
info: This page is owned by the Solutions Architecture team.
title: Jira to GitLab VSA Integration
breadcrumbs:
- doc
- solutions
- components
---
{{< details >}}
- Tier: Premium, Ultimate
- Offering: GitLab.com, GitLab Self-Managed, GitLab Dedicated
{{< /details >}}
GitLab [Value Stream Analytics (VSA)](../../user/group/value_stream_analytics/_index.md) provides powerful insights into your development workflow, tracking key metrics such as:
- **Lead time**: Time from issue creation to completion
- **Issues created**: Number of new issues in a given time period
- **Issues closed**: Number of resolved issues in a given time period
For teams using Jira for issue tracking while leveraging GitLab for development, this integration enables automatic replication of Jira issues to GitLab in real-time. This ensures accurate VSA metrics without requiring teams to change their existing Jira workflows.
The integration also populates the GitLab **Value Streams Dashboard** (Ultimate only), which provides an overview of key DevSecOps metrics and can be found under **Analyze > Analytics dashboards** in your GitLab project or group.
**NOTE**: A similar integration exists for incident replication to generate specific DORA metrics (Change Failure Rate and Time to Restore Service). If you're interested in incident replication, refer to the [Jira Incident Replicator](jira_dora.md).
## Architecture
We will create 2 automation workflows using Jira automation:
1. Create GitLab issues when they are created in Jira
1. Close GitLab issues when they are resolved in Jira
### Issue Creation
When a new issue is created in Jira, the automation workflow sends a POST request to the GitLab Issues API to create a corresponding issue in the specified GitLab project.
### Issue Resolution
When a Jira issue transitions to a resolved state (Closed, Done, Resolved), the automation workflow sends a PUT request to close the corresponding GitLab issue.
## Setup
### Pre-requisites
This walkthrough assumes that you have:
- A GitLab project where you want VSA analytics to be generated
- A Jira project to replicate issues from
- GitLab Ultimate or Premium license (for Value Stream Analytics features)
Jira places [limits](https://www.atlassian.com/software/jira/pricing) on the frequency of Automation runs depending on your Jira license:
| **Tier** | **Limit** |
|------------|------------------------------|
| Free | 100 runs per month |
| Standard | 1700 runs per month |
| Premium | 1000 runs per user per month |
| Enterprise | Unlimited runs |
Each issue creation counts as 1 run, and each issue resolution counts as 1 run.
### GitLab Project Access Token
First, we need to create a GitLab project access token with the necessary permissions to create and update issues via the API.
1. Navigate to your GitLab project where you want Jira issues to be replicated. From the sidebar, go to **Settings > Access Tokens**.
1. Click **Add new token**.
1. Set the following configuration:
- **Token name**: `Jira VSA Integration` (or any descriptive name)
- **Expiration date**: Set according to your security policies
- **Role**: `Owner` (This is required to set custom issue IDs)
- **Scopes**: Check `api` (full API access)
**Important**: An **Owner** level access token is required because the integration needs to force-set custom issue IDs when creating issues in GitLab. This ensures that when Jira issues are closed, the automation can identify and close the corresponding GitLab issue using the same ID mapping. Without the Owner role, the GitLab API will not allow setting custom issue IDs, breaking the synchronization between Jira issue closure and GitLab issue closure.
1. Click **Create project access token** and save the generated token securely - you'll need it for the Jira automation setup.
### Jira Issue Creation Workflow
To automatically create GitLab issues when Jira issues are created, we'll use [Jira automation](https://community.atlassian.com/t5/Jira-articles/Automation-for-Jira-Send-web-request-using-Jira-REST-API/ba-p/1443828).
1. Navigate to your Jira project. From the sidebar, head to **Project settings > Automation**.
1. Click **Create rule** at the top-right.
1. For your trigger, search for and select **Issue created**. Click **Save**.
1. *Optional*: Add conditions to filter which issues should be replicated. For example, you might want to add an **Issue fields condition** to only replicate issues of certain types or with specific labels.
1. Select **THEN: Add an action**. Search for and select **Send web request**.
1. Configure the web request:
- **Web request URL**: `https://gitlab.com/api/v4/projects/<GITLAB_PROJECT_ID>/issues` (replace `gitlab.com` with your GitLab instance URL if self-hosted, and `<GITLAB_PROJECT_ID>` with your GitLab project's numerical ID, e.g., `42718690`)
- **HTTP method**: **POST**
- **Web request body**: **Custom data**
1. Add the following headers:
| Name | Value |
| ------ | ------ |
| Authorization | Bearer `<YOUR_GITLAB_TOKEN>` |
| Content-Type | `application/json` |
Set the Authorization header to "Hidden" for security.
1. In the **Custom data** field, enter:
```json
{
"title": "{{issue.summary}}",
"iid": {{issue.key.replace("VSA-", "1000")}}
}
```
Replace `"VSA-"` with your Jira project prefix (e.g., if your Jira issues are numbered `PROJ-123`, use `"PROJ-"`). The `1000` is a base number that gets added to ensure no conflict with issues that may have been created directly within GitLab itself via the UI - you can adjust this value as needed.
1. Click **Save**, give your automation a descriptive name (e.g., `Jira to GitLab Issue Creation`), and click **Turn it on**.
### Jira Issue Resolution Workflow
Create a second automation workflow to close GitLab issues when Jira issues are resolved:
1. Follow steps 1-2 from the creation workflow to start a new rule.
1. Set the trigger to **Issue transitioned**:
- Leave "From status" field blank
- Set "To status" to resolved statuses: `Closed`, `Done`, `Resolved` (adjust based on your Jira workflow)
1. Skip conditions (or add custom ones if needed).
1. Add a **Send web request** action with:
- **Web request URL**: `https://gitlab.com/api/v4/projects/<GITLAB_PROJECT_ID>/issues/{{issue.key.replace("<JIRA_PROJECT_PREFIX>-", "1000").urlEncode}}` (replace `gitlab.com` with your GitLab instance URL if self-hosted, `<GITLAB_PROJECT_ID>` with your GitLab project's numerical ID, and `<JIRA_PROJECT_PREFIX>` with your Jira project prefix like `VSA` or `PROJ`)
- **HTTP method**: **PUT**
- **Web request body**: **Custom data**
1. Use the same headers as the creation workflow.
1. In the **Custom data** field, enter:
```json
{
"state_event": "close"
}
```
1. Save and enable the automation rule with a descriptive name (e.g., `Jira to GitLab Issue Closer`).
## Value Stream Analytics Configuration
Once your automation workflows are active, GitLab will begin receiving issue data. Here's how to access your analytics:
### Value Streams Dashboard (Automatic - Ultimate Only)
The **Value Streams Dashboard** is automatically populated with metrics from your replicated issues and is available with GitLab Ultimate:
1. In your GitLab project or group, navigate to **Analyze > Analytics dashboards**
1. Click on **Value Streams Dashboard**
1. You'll see metrics including Issues created, Issues closed, Lead time, and Cycle time
### Value Stream Analytics (Requires Setup - Premium and Ultimate)
For more detailed analytics and custom value streams (available with GitLab Premium and Ultimate):
1. Navigate to **Analyze > Value stream analytics** in your GitLab project or group
1. Click **New value stream** to create a custom value stream
1. Configure stages and workflows according to your development process
1. Metrics like lead time and new issues count will be automatically generated and displayed next to the stages you create
1. Refer to the [GitLab Value Stream Analytics documentation](../../user/group/value_stream_analytics/_index.md#create-a-value-stream) for detailed setup instructions
## Multi-Project Considerations
If you want to replicate issues from multiple Jira projects using a single set of automation rules, consider using a timestamp-based approach for generating unique issue IDs instead of the project prefix method:
Replace the `iid` value in your custom data with:
```json
"iid": {{issue.created.replace("-","").replace("T","").replace(":","").replace(".","").replace("+","")}}
```
This converts the creation timestamp (format: `2025-02-15T09:45:32.7+0000`) into a numeric value. Note that this approach may result in very long issue IDs and has a small risk of conflicts if two issues are created at exactly the same time.
## Resources
- [GitLab Value Stream Analytics](../../user/group/value_stream_analytics/_index.md)
- [Create a Value Stream](../../user/group/value_stream_analytics/_index.md#create-a-value-stream)
- [GitLab Value Streams Dashboard](../../user/analytics/value_streams_dashboard.md)
- [GitLab Issues API](../../api/issues.md)
- [Create new issue](../../api/issues.md#new-issue)
- [Edit issue](../../api/issues.md#edit-an-issue)
- [GitLab Project Access Tokens](../../user/project/settings/project_access_tokens.md)
- [Jira automation with web requests](https://community.atlassian.com/t5/Jira-articles/Automation-for-Jira-Send-web-request-using-Jira-REST-API/ba-p/1443828)
|
https://docs.gitlab.com/solutions/integrated_snyk
|
https://gitlab.com/gitlab-org/gitlab/-/tree/master/doc/solutions/integrated_snyk.md
|
2025-08-13
|
doc/solutions/components
|
[
"doc",
"solutions",
"components"
] |
integrated_snyk.md
|
Solutions Architecture
|
Solutions Architecture
|
This page is owned by the Solutions Architecture team.
|
GitLab Application Security Workflow Integrated with Snyk
| null |
{{< details >}}
- Tier: Ultimate
- Offering: GitLab.com, GitLab Self-Managed, GitLab Dedicated
{{< /details >}}
## Getting Started
### Download the Solution Component
1. Obtain the invitation code from your account team.
1. Download the solution component from [the solution component webstore](https://cloud.gitlab-accelerator-marketplace.com) by using your invitation code.
## Snyk Integration
This is an integration between Snyk and GitLab CI via a GitLab CI/CD Component.
## Snyk workflow
This project has a component that runs the Snyk CLI and outputs the scan report in the SARIF format. It calls a separate component that converts SARIF to the GitLab vulnerability record format using a job based on the semgrep base image.
There is a versioned container in the container registry that has a node base image with the Snyk CLI installed on top. This is the image used in the Snyk component job.
The `.gitlab-ci.yml` file builds the container image, tests, and versions the component.
### Versioning
This project follows semantic versioning.
|
---
stage: Solutions Architecture
group: Solutions Architecture
info: This page is owned by the Solutions Architecture team.
title: GitLab Application Security Workflow Integrated with Snyk
breadcrumbs:
- doc
- solutions
- components
---
{{< details >}}
- Tier: Ultimate
- Offering: GitLab.com, GitLab Self-Managed, GitLab Dedicated
{{< /details >}}
## Getting Started
### Download the Solution Component
1. Obtain the invitation code from your account team.
1. Download the solution component from [the solution component webstore](https://cloud.gitlab-accelerator-marketplace.com) by using your invitation code.
## Snyk Integration
This is an integration between Snyk and GitLab CI via a GitLab CI/CD Component.
## Snyk workflow
This project has a component that runs the Snyk CLI and outputs the scan report in the SARIF format. It calls a separate component that converts SARIF to the GitLab vulnerability record format using a job based on the semgrep base image.
There is a versioned container in the container registry that has a node base image with the Snyk CLI installed on top. This is the image used in the Snyk component job.
The `.gitlab-ci.yml` file builds the container image, tests, and versions the component.
### Versioning
This project follows semantic versioning.
|
https://docs.gitlab.com/solutions/regulatedindustry_sdlc
|
https://gitlab.com/gitlab-org/gitlab/-/tree/master/doc/solutions/regulatedindustry_sdlc.md
|
2025-08-13
|
doc/solutions/components
|
[
"doc",
"solutions",
"components"
] |
regulatedindustry_sdlc.md
|
Solutions Architecture
|
Solutions Architecture
|
This page is owned by the Solutions Architecture team.
|
Sectors - Regulated Industry Solution
| null |
{{< details >}}
- Tier: Ultimate
- Offering: GitLab.com, GitLab Self-Managed, GitLab Dedicated
{{< /details >}}
This document provides the instruction and functional detail for GitLab Regulated Industry SDLC Compliance Solution.
<!--
Note: This page is not in the Global Navigation as it does not contain any content.
When the content is added, you can remove `ignore_in_report: true` from the frontmatter
at the top of the page. Then add it to the navigation: https://docs.gitlab.com/development/documentation/site_architecture/global_nav/#add-a-navigation-entry
-->
|
---
stage: Solutions Architecture
group: Solutions Architecture
info: This page is owned by the Solutions Architecture team.
ignore_in_report: true
title: Sectors - Regulated Industry Solution
breadcrumbs:
- doc
- solutions
- components
---
{{< details >}}
- Tier: Ultimate
- Offering: GitLab.com, GitLab Self-Managed, GitLab Dedicated
{{< /details >}}
This document provides the instruction and functional detail for GitLab Regulated Industry SDLC Compliance Solution.
<!--
Note: This page is not in the Global Navigation as it does not contain any content.
When the content is added, you can remove `ignore_in_report: true` from the frontmatter
at the top of the page. Then add it to the navigation: https://docs.gitlab.com/development/documentation/site_architecture/global_nav/#add-a-navigation-entry
-->
|
https://docs.gitlab.com/solutions/securitykpi
|
https://gitlab.com/gitlab-org/gitlab/-/tree/master/doc/solutions/securitykpi.md
|
2025-08-13
|
doc/solutions/components
|
[
"doc",
"solutions",
"components"
] |
securitykpi.md
|
Solutions Architecture
|
Solutions Architecture
|
This page is owned by the Solutions Architecture team.
|
Security Metrics and KPIs
| null |
{{< details >}}
- Tier: Ultimate
- Offering: GitLab.com, GitLab Self-Managed, GitLab Dedicated
{{< /details >}}
The document describes the installation, configuration and user guide of the GitLab Security Metrics and KPIs Solution Component. This security solution component provides metrics and KPIs that can be viewed by business units, time range, vulnerability severity and security types. It can provide a snapshot of the security posture on a monthly or quarterly basis with PDF documents. The data is visualized using a dashboard in Splunk.
This solution exports vulnerability data from GitLab projects or groups using the GraphQL API, sends it to Splunk through the HTTP Event Collector (HEC), and includes an out-of-the-box dashboard for security metrics visualization. The export process is designed to run as a GitLab CI/CD pipeline on a scheduled basis.
## Getting Started
### Download the Solution Component
1. Obtain the invitation code from your account team.
1. Download the solution component from [the solution component webstore](https://cloud.gitlab-accelerator-marketplace.com) by using your invitation code.
### Set Up the Solution Component Project
1. Create a new GitLab project to host this exporter.
1. Copy the provided files into your project:
- `export_vulns.py`
- `send_to_splunk.py`
- `requirements.txt`
- `.gitlab-ci.yml`
1. Configure the required CI/CD variables in your project settings.
1. Set up a pipeline schedule (for example, daily or weekly).
## How It Works
The solution consists of two main components:
1. A vulnerability exporter that fetches data from GitLab Security Dashboard
1. A Splunk ingester that processes the exported data and sends it to Splunk HEC
The pipeline runs in two stages:
1. `extract`: Fetches vulnerabilities and saves to CSV
1. `ingest`: Sends the vulnerability data to Splunk
## Configuration
### Required CI/CD Variables
| Variable | Description | Example Value |
|----------|-------------|---------------|
| `SCOPE` | Target scope for vulnerability scanning | `group:security/appsec` or `security/my-project` |
| `GRAPHQL_API_TOKEN` | GitLab personal access token with API access | `glpat-XXXXXXXXXXXXXXXX` |
| `GRAPHQL_API_URL` | GitLab GraphQL API URL | `https://gitlab.com/api/graphql` |
| `SPLUNK_HEC_TOKEN` | Splunk HTTP Event Collector token | `11111111-2222-3333-4444-555555555555` |
| `SPLUNK_HEC_URL` | Splunk HEC endpoint URL | `https://splunk.company.com:8088/services/collector` |
### Optional CI/CD Variables
| Variable | Description | Example Value | Default |
|----------|-------------|---------------|---------|
| `SEVERITY_FILTER` | Comma-separated list of severity levels | `CRITICAL,HIGH,MEDIUM` | All severities |
| `VULN_TIME_WINDOW` | Time window for vulnerability collection | `24h`, `7d`, or `all` | `24h` |
### Scope Configuration
The `SCOPE` variable determines which projects or groups to scan:
- For a project: `mygroup/myproject`
- For a group: `group:mygroup/subgroup`
- For the entire instance: `instance`
### Severity Filter Examples
Valid severity levels:
- `CRITICAL`
- `HIGH`
- `MEDIUM`
- `LOW`
- `UNKNOWN`
Example combinations:
- `CRITICAL,HIGH`
- `CRITICAL,HIGH,MEDIUM`
- Leave empty to include all severities
### Time Window Configuration
The `VULN_TIME_WINDOW` variable controls how far back to look for vulnerabilities:
- Format: `<number><unit>` where:
- `number`: Any positive integer
- `unit`: `h` for hours or `d` for days
- Examples:
- `24h`: Last 24 hours
- `7h`: Last 7 hours
- `15d`: Last 15 days
- `30d`: Last 30 days
- `all`: All vulnerabilities (useful for first run)
Default value: `24h`
Example pipeline configurations:
```yaml
# For 12-hour window
variables:
VULN_TIME_WINDOW: "12h"
# For 3-day window
variables:
VULN_TIME_WINDOW: "3d"
# For all vulnerabilities
variables:
VULN_TIME_WINDOW: "all"
```
Schedule your pipeline based on your chosen window. For example:
- For 12h: Schedule twice daily
- For 3d: Schedule every 3 days
- Add some overlap in scheduling to ensure no vulnerabilities are missed
## Pipeline Setup
1. **First Run**:
- Set `VULN_TIME_WINDOW: "all"` to collect all historical vulnerabilities
- Run the pipeline once
1. **Ongoing Collection**:
- Set `VULN_TIME_WINDOW` to your desired window (`24h` or `7d`)
- Set up a pipeline schedule:
- For `24h`: Schedule daily
- For `7d`: Schedule weekly
## Splunk Integration
The script sends vulnerabilities as events to Splunk.
### Index Configuration
1. Create a new index named `gitlab_vulns` in Splunk
1. When creating your HEC token:
- Set the default **index** to `gitlab_vulns` (this index is referenced in the base search of the provided Splunk dashboard)
- Ensure the token has permissions to write to this index
- Ensure that the token has a **sourcetype** that allows event data to be parsed correctly as JSON
Each event includes:
- Detection time
- Vulnerability title and description
- Severity level
- Scanner information
- Project details
- URLs for both project and vulnerability
## Dashboard Setup
The provided dashboard offers comprehensive visibility into your GitLab vulnerability data with the following visualizations:
- P95 Age metrics for Critical and High vulnerabilities (radial gauges)
- Aging Analysis showing the distribution of Critical and High vulnerabilities across age buckets (0-30 days, 31-90 days, 91-180 days, 180+ days)
- Top 10 most frequent CVEs with their occurrence counts
- Vulnerability distribution by project path and severity
- All metrics can be filtered by business unit and time range
To set up the dashboard:
1. **Business Unit Mapping**:
1. Create a CSV file with two columns:
```shell
project_url,business_unit
```
1. Map each GitLab project URL to its corresponding business unit.
1. Upload the file to Splunk as a lookup table:
1. Go to **Settings > Lookups > Lookup table files**.
1. Select **New Lookup Table File**.
1. Upload your CSV file.
1. Set the **Destination filename** to `business_unit_mapping.csv`.
1. Configure permissions:
1. Find the row labeled `<splunk_dir>/etc/apps/search/lookups/business_unit_mapping.csv`.
1. Select **Permissions**.
1. Set the permissions to either:
- Set to **Global** for instance-wide access.
- Share with specific apps or roles as needed.
1. Select **Save**.
1. **Dashboard Installation**:
1. Save the provided `vuln_metrics_dashboard.xml` file.
1. In Splunk:
1. Go to the Search app.
1. Click **Dashboards > Create New Dashboard**.
1. Select **Source** in the edit view.
1. Replace the default XML with the contents of `vuln_metrics_dashboard.xml`.
1. Save the dashboard.
## Output Format
The intermediate CSV file contains:
- `detectedAt`: Detection timestamp
- `title`: Vulnerability title
- `severity`: Severity level
- `primaryIdentifier`: Vulnerability identifier
- `exporter`: Scanner name
- `projectPath`: GitLab project path
- `projectUrl`: Project URL
- `description`: Vulnerability description
- `webUrl`: Vulnerability details URL
## Error Handling
The solution includes:
- Rate limiting handling with exponential backoff
- Batch processing for Splunk ingestion
- Proper error reporting
- Timeout handling
- UTF-8 encoding support
## Best Practices
1. **Token Permissions**:
- GRAPHQL_API_TOKEN needs:
- Read access to target group/project
- Security Dashboard access
- SPLUNK_HEC_TOKEN needs:
- Event submission permissions to target index
1. **Schedule Frequency**:
- Match schedule to your `VULN_TIME_WINDOW`
- Include overlap to prevent missing vulnerabilities
- Consider your organization's SLAs
1. **Monitoring**:
- Monitor pipeline success/failure
- Track number of vulnerabilities exported
- Monitor Splunk ingestion success
## Troubleshooting
Common issues and solutions:
1. **No vulnerabilities exported**:
- Verify SCOPE setting
- Check token permissions
- Verify Security Dashboard access
1. **Splunk ingestion fails**:
- Verify HEC URL and token
- Check network connectivity
- Verify index permissions
|
---
stage: Solutions Architecture
group: Solutions Architecture
info: This page is owned by the Solutions Architecture team.
title: Security Metrics and KPIs
breadcrumbs:
- doc
- solutions
- components
---
{{< details >}}
- Tier: Ultimate
- Offering: GitLab.com, GitLab Self-Managed, GitLab Dedicated
{{< /details >}}
The document describes the installation, configuration and user guide of the GitLab Security Metrics and KPIs Solution Component. This security solution component provides metrics and KPIs that can be viewed by business units, time range, vulnerability severity and security types. It can provide a snapshot of the security posture on a monthly or quarterly basis with PDF documents. The data is visualized using a dashboard in Splunk.
This solution exports vulnerability data from GitLab projects or groups using the GraphQL API, sends it to Splunk through the HTTP Event Collector (HEC), and includes an out-of-the-box dashboard for security metrics visualization. The export process is designed to run as a GitLab CI/CD pipeline on a scheduled basis.
## Getting Started
### Download the Solution Component
1. Obtain the invitation code from your account team.
1. Download the solution component from [the solution component webstore](https://cloud.gitlab-accelerator-marketplace.com) by using your invitation code.
### Set Up the Solution Component Project
1. Create a new GitLab project to host this exporter.
1. Copy the provided files into your project:
- `export_vulns.py`
- `send_to_splunk.py`
- `requirements.txt`
- `.gitlab-ci.yml`
1. Configure the required CI/CD variables in your project settings.
1. Set up a pipeline schedule (for example, daily or weekly).
## How It Works
The solution consists of two main components:
1. A vulnerability exporter that fetches data from GitLab Security Dashboard
1. A Splunk ingester that processes the exported data and sends it to Splunk HEC
The pipeline runs in two stages:
1. `extract`: Fetches vulnerabilities and saves to CSV
1. `ingest`: Sends the vulnerability data to Splunk
## Configuration
### Required CI/CD Variables
| Variable | Description | Example Value |
|----------|-------------|---------------|
| `SCOPE` | Target scope for vulnerability scanning | `group:security/appsec` or `security/my-project` |
| `GRAPHQL_API_TOKEN` | GitLab personal access token with API access | `glpat-XXXXXXXXXXXXXXXX` |
| `GRAPHQL_API_URL` | GitLab GraphQL API URL | `https://gitlab.com/api/graphql` |
| `SPLUNK_HEC_TOKEN` | Splunk HTTP Event Collector token | `11111111-2222-3333-4444-555555555555` |
| `SPLUNK_HEC_URL` | Splunk HEC endpoint URL | `https://splunk.company.com:8088/services/collector` |
### Optional CI/CD Variables
| Variable | Description | Example Value | Default |
|----------|-------------|---------------|---------|
| `SEVERITY_FILTER` | Comma-separated list of severity levels | `CRITICAL,HIGH,MEDIUM` | All severities |
| `VULN_TIME_WINDOW` | Time window for vulnerability collection | `24h`, `7d`, or `all` | `24h` |
### Scope Configuration
The `SCOPE` variable determines which projects or groups to scan:
- For a project: `mygroup/myproject`
- For a group: `group:mygroup/subgroup`
- For the entire instance: `instance`
### Severity Filter Examples
Valid severity levels:
- `CRITICAL`
- `HIGH`
- `MEDIUM`
- `LOW`
- `UNKNOWN`
Example combinations:
- `CRITICAL,HIGH`
- `CRITICAL,HIGH,MEDIUM`
- Leave empty to include all severities
### Time Window Configuration
The `VULN_TIME_WINDOW` variable controls how far back to look for vulnerabilities:
- Format: `<number><unit>` where:
- `number`: Any positive integer
- `unit`: `h` for hours or `d` for days
- Examples:
- `24h`: Last 24 hours
- `7h`: Last 7 hours
- `15d`: Last 15 days
- `30d`: Last 30 days
- `all`: All vulnerabilities (useful for first run)
Default value: `24h`
Example pipeline configurations:
```yaml
# For 12-hour window
variables:
VULN_TIME_WINDOW: "12h"
# For 3-day window
variables:
VULN_TIME_WINDOW: "3d"
# For all vulnerabilities
variables:
VULN_TIME_WINDOW: "all"
```
Schedule your pipeline based on your chosen window. For example:
- For 12h: Schedule twice daily
- For 3d: Schedule every 3 days
- Add some overlap in scheduling to ensure no vulnerabilities are missed
## Pipeline Setup
1. **First Run**:
- Set `VULN_TIME_WINDOW: "all"` to collect all historical vulnerabilities
- Run the pipeline once
1. **Ongoing Collection**:
- Set `VULN_TIME_WINDOW` to your desired window (`24h` or `7d`)
- Set up a pipeline schedule:
- For `24h`: Schedule daily
- For `7d`: Schedule weekly
## Splunk Integration
The script sends vulnerabilities as events to Splunk.
### Index Configuration
1. Create a new index named `gitlab_vulns` in Splunk
1. When creating your HEC token:
- Set the default **index** to `gitlab_vulns` (this index is referenced in the base search of the provided Splunk dashboard)
- Ensure the token has permissions to write to this index
- Ensure that the token has a **sourcetype** that allows event data to be parsed correctly as JSON
Each event includes:
- Detection time
- Vulnerability title and description
- Severity level
- Scanner information
- Project details
- URLs for both project and vulnerability
## Dashboard Setup
The provided dashboard offers comprehensive visibility into your GitLab vulnerability data with the following visualizations:
- P95 Age metrics for Critical and High vulnerabilities (radial gauges)
- Aging Analysis showing the distribution of Critical and High vulnerabilities across age buckets (0-30 days, 31-90 days, 91-180 days, 180+ days)
- Top 10 most frequent CVEs with their occurrence counts
- Vulnerability distribution by project path and severity
- All metrics can be filtered by business unit and time range
To set up the dashboard:
1. **Business Unit Mapping**:
1. Create a CSV file with two columns:
```shell
project_url,business_unit
```
1. Map each GitLab project URL to its corresponding business unit.
1. Upload the file to Splunk as a lookup table:
1. Go to **Settings > Lookups > Lookup table files**.
1. Select **New Lookup Table File**.
1. Upload your CSV file.
1. Set the **Destination filename** to `business_unit_mapping.csv`.
1. Configure permissions:
1. Find the row labeled `<splunk_dir>/etc/apps/search/lookups/business_unit_mapping.csv`.
1. Select **Permissions**.
1. Set the permissions to either:
- Set to **Global** for instance-wide access.
- Share with specific apps or roles as needed.
1. Select **Save**.
1. **Dashboard Installation**:
1. Save the provided `vuln_metrics_dashboard.xml` file.
1. In Splunk:
1. Go to the Search app.
1. Click **Dashboards > Create New Dashboard**.
1. Select **Source** in the edit view.
1. Replace the default XML with the contents of `vuln_metrics_dashboard.xml`.
1. Save the dashboard.
## Output Format
The intermediate CSV file contains:
- `detectedAt`: Detection timestamp
- `title`: Vulnerability title
- `severity`: Severity level
- `primaryIdentifier`: Vulnerability identifier
- `exporter`: Scanner name
- `projectPath`: GitLab project path
- `projectUrl`: Project URL
- `description`: Vulnerability description
- `webUrl`: Vulnerability details URL
## Error Handling
The solution includes:
- Rate limiting handling with exponential backoff
- Batch processing for Splunk ingestion
- Proper error reporting
- Timeout handling
- UTF-8 encoding support
## Best Practices
1. **Token Permissions**:
- GRAPHQL_API_TOKEN needs:
- Read access to target group/project
- Security Dashboard access
- SPLUNK_HEC_TOKEN needs:
- Event submission permissions to target index
1. **Schedule Frequency**:
- Match schedule to your `VULN_TIME_WINDOW`
- Include overlap to prevent missing vulnerabilities
- Consider your organization's SLAs
1. **Monitoring**:
- Monitor pipeline success/failure
- Track number of vulnerabilities exported
- Monitor Splunk ingestion success
## Troubleshooting
Common issues and solutions:
1. **No vulnerabilities exported**:
- Verify SCOPE setting
- Check token permissions
- Verify Security Dashboard access
1. **Splunk ingestion fails**:
- Verify HEC URL and token
- Check network connectivity
- Verify index permissions
|
https://docs.gitlab.com/solutions/guide_on_sod
|
https://gitlab.com/gitlab-org/gitlab/-/tree/master/doc/solutions/guide_on_sod.md
|
2025-08-13
|
doc/solutions/components
|
[
"doc",
"solutions",
"components"
] |
guide_on_sod.md
|
Solutions Architecture
|
Solutions Architecture
|
This page is owned by the Solutions Architecture team.
|
GitLab Tutorial Guide on Separation of Duties
| null |
{{< details >}}
- Tier: Ultimate
- Offering: GitLab.com, GitLab Self-Managed, GitLab Dedicated
{{< /details >}}
This document provides an overview of GitLab Separation of Duties (SoD) solution through Role-Based Access Control (RBAC). The solution ensures compliance with security principles by preventing any single individual from having complete control over critical processes in the software development lifecycle.
## Getting Started
### Access the Solution Component
1. Obtain the invitation code from your account team.
1. Access the solution component from [the solution component webstore](https://cloud.gitlab-accelerator-marketplace.com) by using your invitation code.
## What is Separation of Duties
Separation of Duties is a fundamental security principle that ensures no single individual has complete control over critical processes. In software development, SoD prevents unauthorized or accidental code releases into production environments by distributing responsibilities among different roles and teams.
The GitLab approach to implementing SoD through Role-Based Access Control (RBAC) provides:
- Clear separation between development and deployment roles
- Protected environments to control deployment access
- Protected branches to prevent unauthorized code modifications
- Merge request approval policies to enforce code review
- Built-in audit capabilities for compliance verification
## Key Components of GitLab SoD Solution
### Role-Based Access Control (RBAC)
RBAC forms the framework for implementing and enforcing SoD. It governs permissions and responsibilities across the platform, ensuring compliance with the principles of least privilege. Through RBAC, organizations can:
- Implement holistic user management with granular role-based controls
- Assign roles with the least privileged access principles
- Maintain visibility into roles and permissions through audit/reporting
### Feature Branch Workflow
The feature branch workflow supports SoD by defining clear boundaries between development activities and production deployment:
- Development teams can modify code and trigger test pipelines in feature branches
- Security teams manage approval policies for quality gates
- Merge requests require independent review from non-authors
### Protected Branches & Environments
The default branch play a key role in enforcing SoD:
- Protected environments restrict deployments to designated teams
- Deployer teams have permission to execute deployments but are restricted from modifying source code
- Protected branches prevent unauthorized merges and pushes
### Audit & Compliance Capabilities
GitLab provides robust audit capabilities to support compliance requirements:
- Automatically generated release evidence
- Event logging for default branch activities
### Prerequisites
To fully implement the GitLab SoD solution, organizations need:
- GitLab Ultimate License
- Properly configured CI/CD pipelines
- User groups with a clear separation between development and deployment roles
### Additional Resources
For more information on GitLab SoD implementation, refer to:
- [GitLab Role & Permissions Documentation](../../user/permissions.md)
- [Protected Branches Documentation](../../user/project/repository/branches/protected.md)
- [Protected Environments Documentation](../../ci/environments/protected_environments.md)
- [Merge Request Approvals Documentation](../../user/project/merge_requests/approvals/_index.md)
|
---
stage: Solutions Architecture
group: Solutions Architecture
info: This page is owned by the Solutions Architecture team.
title: GitLab Tutorial Guide on Separation of Duties
breadcrumbs:
- doc
- solutions
- components
---
{{< details >}}
- Tier: Ultimate
- Offering: GitLab.com, GitLab Self-Managed, GitLab Dedicated
{{< /details >}}
This document provides an overview of GitLab Separation of Duties (SoD) solution through Role-Based Access Control (RBAC). The solution ensures compliance with security principles by preventing any single individual from having complete control over critical processes in the software development lifecycle.
## Getting Started
### Access the Solution Component
1. Obtain the invitation code from your account team.
1. Access the solution component from [the solution component webstore](https://cloud.gitlab-accelerator-marketplace.com) by using your invitation code.
## What is Separation of Duties
Separation of Duties is a fundamental security principle that ensures no single individual has complete control over critical processes. In software development, SoD prevents unauthorized or accidental code releases into production environments by distributing responsibilities among different roles and teams.
The GitLab approach to implementing SoD through Role-Based Access Control (RBAC) provides:
- Clear separation between development and deployment roles
- Protected environments to control deployment access
- Protected branches to prevent unauthorized code modifications
- Merge request approval policies to enforce code review
- Built-in audit capabilities for compliance verification
## Key Components of GitLab SoD Solution
### Role-Based Access Control (RBAC)
RBAC forms the framework for implementing and enforcing SoD. It governs permissions and responsibilities across the platform, ensuring compliance with the principles of least privilege. Through RBAC, organizations can:
- Implement holistic user management with granular role-based controls
- Assign roles with the least privileged access principles
- Maintain visibility into roles and permissions through audit/reporting
### Feature Branch Workflow
The feature branch workflow supports SoD by defining clear boundaries between development activities and production deployment:
- Development teams can modify code and trigger test pipelines in feature branches
- Security teams manage approval policies for quality gates
- Merge requests require independent review from non-authors
### Protected Branches & Environments
The default branch play a key role in enforcing SoD:
- Protected environments restrict deployments to designated teams
- Deployer teams have permission to execute deployments but are restricted from modifying source code
- Protected branches prevent unauthorized merges and pushes
### Audit & Compliance Capabilities
GitLab provides robust audit capabilities to support compliance requirements:
- Automatically generated release evidence
- Event logging for default branch activities
### Prerequisites
To fully implement the GitLab SoD solution, organizations need:
- GitLab Ultimate License
- Properly configured CI/CD pipelines
- User groups with a clear separation between development and deployment roles
### Additional Resources
For more information on GitLab SoD implementation, refer to:
- [GitLab Role & Permissions Documentation](../../user/permissions.md)
- [Protected Branches Documentation](../../user/project/repository/branches/protected.md)
- [Protected Environments Documentation](../../ci/environments/protected_environments.md)
- [Merge Request Approvals Documentation](../../user/project/merge_requests/approvals/_index.md)
|
https://docs.gitlab.com/solutions/integrated_servicenow
|
https://gitlab.com/gitlab-org/gitlab/-/tree/master/doc/solutions/integrated_servicenow.md
|
2025-08-13
|
doc/solutions/components
|
[
"doc",
"solutions",
"components"
] |
integrated_servicenow.md
|
Solutions Architecture
|
Solutions Architecture
|
This page is owned by the Solutions Architecture team.
|
Integrated Change Management - ServiceNow
| null |
{{< details >}}
- Tier: Premium, Ultimate
- Offering: GitLab.com, GitLab Self-Managed, GitLab Dedicated
- ServiceNow Version: Latest version, Xanadu and backward compatibility with previous versions
{{< /details >}}
This document provides the instruction and functional detail for GitLab to orcestrate the change management with integrated ServiceNow solution using ServiceNow DevOps Change Velocity.
With the ServiceNow DevOps Change Velocity integration, it's able to track information about activity in GitLab repositories and CI/CD pipelines in ServiceNow.
It automates the creation of change requests and automatically approve the change requests based on the policy critieria when it's integrated with GitLab CI/CD pipelines.
This document shows you how to
1. Integrate ServiceNow with GitLab with Change Velocity for change management,
1. Create in the GitLab CI/CD pipeline automatically the change request in ServiceNow,
1. Approve the change request in ServiceNow if it requires CAB review and approval,
1. Start the production deployment based on the change request approval.
## Getting Started
### Download the Solution Component
1. Obtain the invitation code from your account team.
1. Download the solution component from [the solution component webstore](https://cloud.gitlab-accelerator-marketplace.com) by using your invitation code.
## Integration Options for Change Management
There are multiple ways to integrate GitLab with ServiceNow. The followings options are provided in this solution component:
1. ServiceNow DevOps Change Velocity for Built-in Change Request Process
1. ServiceNow DevOps Change Velocity with Custom Change Request with Velocity Container Image
1. ServiceNow Rest API for custom Change Request Process
## ServiceNow DevOps Change Velocity
Upon installing and configuring DevOps Change Velocity from ServiceNow store, enable change control through automated change creation in the DevOps Change Workspace Directly.
### Built-in Change Request Process
ServiceNow DevOps Change Velocity provides built-in change request model for normal change process and the change request created automatically has default naming convention.
The normal change process requires the change request to be approved before the deployment pipeline job to production can occur.
#### Setup the Pipeline and Change Request Jobs
Use the `gitlab-ci-workflow1.yml` sample pipeline in the solution repository as a starting point.
Check below for the steps to enable the automatic change creation and pass the change attributes through the pipeline.
Note: for more detailed instructions, see [Automate DevOps change request creation](https://www.servicenow.com/docs/bundle/yokohama-it-service-management/page/product/enterprise-dev-ops/task/automate-devops-change-request.html).
Below are the high-level steps:
1. From the DevOps Change Workspace, navigate to the Change tab, then select Automate change.
1. In the Application field, select the application that you want to associate with the pipeline for which you want to automate change request creation, and select Next.
1. Select the pipeline that has the step (stage) from where you want to trigger the automated creation of change requests. For example, the change request creation step.
1. Select the step in the pipeline from where you want to trigger the automated creation of a change request.
1. Specify the change attributes in the change fields and enable change receipt by selecting the Change receipt option.
1. Modify your pipeline and use the corresponding code snippet to enable change control and specify change attributes. For example, adding the following two configurations to the job that has change control enabled:
```yaml
when: manual
allow_failure: false
```
#### Run Pipeline with Change Management
After the previous steps are completed, the project CD pipeline can incorporate the jobs illustrated in the `gitlab-ci-workflow1.yml` sample pipeline.
To run a pipeline with Change Management:
1. In ServiceNow, Change control is enabled for one of the stages in the pipeline.
1. In GitLab, the pipeline job with the change control function runs.
1. In ServiceNow, a change request is automatically created in ServiceNow.
1. In ServiceNow, approve the change request
1. Pipeline resumes and begins the next job for deploying to the production environment upon the approval of the change request.
### Custom Actions with Velocity Container Image
Use the ServiceNow custom actions via the DevOps Change Velocity Docker image to set Change Request title, description, change plan, rollback plan, and data related to artifacts to be deployed, and package registration. This allows you to customize the change request descriptions instead of passing the pipeline metadata as the change request description.
#### Setup the Pipeline and Change Request Jobs
This is an add-on to the ServiceNow DevOps Change Velocity, so the previous setup steps are the same. You just need to include the Docker image in the pipeline definition.
Use the `gitlab-ci-workflow2.yml` sample pipeline in this repository as an example.
1. Specify the image to use in the job. Update the image version as needed.
```yaml
image: servicenowdocker/sndevops:5.0.0
```
1. Use the CLI for specific actions. For example, to use the sndevops CLI to create a change request
```yaml
sndevopscli create change -p {
"changeStepDetails": {
"timeout": 3600,
"interval": 100
},
"autoCloseChange": true,
"attributes": {
"short_description": "'"${CHANGE_REQUEST_SHORT_DESCRIPTION}"'",
"description": "'"${CHANGE_REQUEST_DESCRIPTION}"'",
"assignment_group": "'"${ASSIGNMENT_GROUP_ID}"'",
"implementation_plan": "'"${CR_IMPLEMENTATION_PLAN}"'",
"backout_plan": "'"${CR_BACKOUT_PLAN}"'",
"test_plan": "'"${CR_TEST_PLAN}"'"
}
}
```
#### Run Pipeline with Custom Change Management
Use the `gitlab-ci-workflow2.yml` sample pipeline as a starting point.
After the previous steps are completed, the project CD pipeline can incorporate the jobs illustrated in the `gitlab-ci-workflow2.yml` sample pipeline.
To run a pipeline with custom Change Management:
1. In ServiceNow, change control is enabled for one of the stages in the pipeline.
1. In GitLab, the pipeline job with the change control function runs.
1. In ServiceNow, a change request is created with custom title, description and any other fields supplied by the pipeline variable values using `servicenowdocker/sndevops` image.
1. In GitLab, change request number and other information can be found in the pipeline details. The pipeline job will remain running until the change request is approved, then it will proceed to the next job.
1. In ServiceNow, approve the change request.
1. In GitLab, the Pipeline job resumes and begins the next job which is the deployment to the production environment upon the approval of the change request.
|
---
stage: Solutions Architecture
group: Solutions Architecture
info: This page is owned by the Solutions Architecture team.
title: Integrated Change Management - ServiceNow
breadcrumbs:
- doc
- solutions
- components
---
{{< details >}}
- Tier: Premium, Ultimate
- Offering: GitLab.com, GitLab Self-Managed, GitLab Dedicated
- ServiceNow Version: Latest version, Xanadu and backward compatibility with previous versions
{{< /details >}}
This document provides the instruction and functional detail for GitLab to orcestrate the change management with integrated ServiceNow solution using ServiceNow DevOps Change Velocity.
With the ServiceNow DevOps Change Velocity integration, it's able to track information about activity in GitLab repositories and CI/CD pipelines in ServiceNow.
It automates the creation of change requests and automatically approve the change requests based on the policy critieria when it's integrated with GitLab CI/CD pipelines.
This document shows you how to
1. Integrate ServiceNow with GitLab with Change Velocity for change management,
1. Create in the GitLab CI/CD pipeline automatically the change request in ServiceNow,
1. Approve the change request in ServiceNow if it requires CAB review and approval,
1. Start the production deployment based on the change request approval.
## Getting Started
### Download the Solution Component
1. Obtain the invitation code from your account team.
1. Download the solution component from [the solution component webstore](https://cloud.gitlab-accelerator-marketplace.com) by using your invitation code.
## Integration Options for Change Management
There are multiple ways to integrate GitLab with ServiceNow. The followings options are provided in this solution component:
1. ServiceNow DevOps Change Velocity for Built-in Change Request Process
1. ServiceNow DevOps Change Velocity with Custom Change Request with Velocity Container Image
1. ServiceNow Rest API for custom Change Request Process
## ServiceNow DevOps Change Velocity
Upon installing and configuring DevOps Change Velocity from ServiceNow store, enable change control through automated change creation in the DevOps Change Workspace Directly.
### Built-in Change Request Process
ServiceNow DevOps Change Velocity provides built-in change request model for normal change process and the change request created automatically has default naming convention.
The normal change process requires the change request to be approved before the deployment pipeline job to production can occur.
#### Setup the Pipeline and Change Request Jobs
Use the `gitlab-ci-workflow1.yml` sample pipeline in the solution repository as a starting point.
Check below for the steps to enable the automatic change creation and pass the change attributes through the pipeline.
Note: for more detailed instructions, see [Automate DevOps change request creation](https://www.servicenow.com/docs/bundle/yokohama-it-service-management/page/product/enterprise-dev-ops/task/automate-devops-change-request.html).
Below are the high-level steps:
1. From the DevOps Change Workspace, navigate to the Change tab, then select Automate change.
1. In the Application field, select the application that you want to associate with the pipeline for which you want to automate change request creation, and select Next.
1. Select the pipeline that has the step (stage) from where you want to trigger the automated creation of change requests. For example, the change request creation step.
1. Select the step in the pipeline from where you want to trigger the automated creation of a change request.
1. Specify the change attributes in the change fields and enable change receipt by selecting the Change receipt option.
1. Modify your pipeline and use the corresponding code snippet to enable change control and specify change attributes. For example, adding the following two configurations to the job that has change control enabled:
```yaml
when: manual
allow_failure: false
```
#### Run Pipeline with Change Management
After the previous steps are completed, the project CD pipeline can incorporate the jobs illustrated in the `gitlab-ci-workflow1.yml` sample pipeline.
To run a pipeline with Change Management:
1. In ServiceNow, Change control is enabled for one of the stages in the pipeline.
1. In GitLab, the pipeline job with the change control function runs.
1. In ServiceNow, a change request is automatically created in ServiceNow.
1. In ServiceNow, approve the change request
1. Pipeline resumes and begins the next job for deploying to the production environment upon the approval of the change request.
### Custom Actions with Velocity Container Image
Use the ServiceNow custom actions via the DevOps Change Velocity Docker image to set Change Request title, description, change plan, rollback plan, and data related to artifacts to be deployed, and package registration. This allows you to customize the change request descriptions instead of passing the pipeline metadata as the change request description.
#### Setup the Pipeline and Change Request Jobs
This is an add-on to the ServiceNow DevOps Change Velocity, so the previous setup steps are the same. You just need to include the Docker image in the pipeline definition.
Use the `gitlab-ci-workflow2.yml` sample pipeline in this repository as an example.
1. Specify the image to use in the job. Update the image version as needed.
```yaml
image: servicenowdocker/sndevops:5.0.0
```
1. Use the CLI for specific actions. For example, to use the sndevops CLI to create a change request
```yaml
sndevopscli create change -p {
"changeStepDetails": {
"timeout": 3600,
"interval": 100
},
"autoCloseChange": true,
"attributes": {
"short_description": "'"${CHANGE_REQUEST_SHORT_DESCRIPTION}"'",
"description": "'"${CHANGE_REQUEST_DESCRIPTION}"'",
"assignment_group": "'"${ASSIGNMENT_GROUP_ID}"'",
"implementation_plan": "'"${CR_IMPLEMENTATION_PLAN}"'",
"backout_plan": "'"${CR_BACKOUT_PLAN}"'",
"test_plan": "'"${CR_TEST_PLAN}"'"
}
}
```
#### Run Pipeline with Custom Change Management
Use the `gitlab-ci-workflow2.yml` sample pipeline as a starting point.
After the previous steps are completed, the project CD pipeline can incorporate the jobs illustrated in the `gitlab-ci-workflow2.yml` sample pipeline.
To run a pipeline with custom Change Management:
1. In ServiceNow, change control is enabled for one of the stages in the pipeline.
1. In GitLab, the pipeline job with the change control function runs.
1. In ServiceNow, a change request is created with custom title, description and any other fields supplied by the pipeline variable values using `servicenowdocker/sndevops` image.
1. In GitLab, change request number and other information can be found in the pipeline details. The pipeline job will remain running until the change request is approved, then it will proceed to the next job.
1. In ServiceNow, approve the change request.
1. In GitLab, the Pipeline job resumes and begins the next job which is the deployment to the production environment upon the approval of the change request.
|
https://docs.gitlab.com/solutions/components/duo_workflow_codestyle
|
https://gitlab.com/gitlab-org/gitlab/-/tree/master/doc/solutions/components/duo_workflow_codestyle.md
|
2025-08-13
|
doc/solutions/components/duo_workflow
|
[
"doc",
"solutions",
"components",
"duo_workflow"
] |
duo_workflow_codestyle.md
|
Solutions Architecture
|
Solutions Architecture
|
This page is owned by the Solutions Architecture team.
|
Duo Workflow Use Case for Applying Coding Style
| null |
{{< details >}}
- Tier: Ultimate with GitLab Duo Workflow
- Offering: GitLab.com
- Status: Experiment
{{< /details >}}
## Getting Started
### Download the Solution Component
1. Obtain the invitation code from your account team.
1. Download the solution component from [the solution component webstore](https://cloud.gitlab-accelerator-marketplace.com) by using your invitation code.
## Duo Workflow Use Case: Improve Java Application with Style Guide
The document describes GitLab Duo Workflow Solution with prompt and context library. The purpose of the solution is to improve appliction coding based on defined style.
This solution provides a GitLab issue as the prompt and the style guide as the context, designed to automate Java style guidelines to codebases using GitLab Duo Workflow. The prompt and context library enables Duo Workflow to:
1. Access centralized style guide content stored in GitLab repository,
1. Understand domain-specific coding standards, and
1. Apply consistent formatting to Java code while preserving functionality.
For detailed information about GitLab Duo Workflow, review [the document here](../../../user/duo_workflow/_index.md).
### Key Benefits
- **Enforces consistent style** across all Java codebases
- **Automates style application** without manual effort
- **Maintains code functionality** while improving readability
- **Integrates with GitLab Workflow** for seamless implementation
- **Reduces code review time** spent addressing style issues
- **Serves as a learning tool** for developers to understand style guidelines
### Sample Result
When properly configured, the prompt will transform your code to match enterprise standards, similar to the transformation shown in this diff:
## Configure the Solution Prompt and Context Library
### Basic Setup
To run the agentic workflow to review and apply style to your application, you need to set up this use case prompt and context library.
1. **Set up the prompt and contet library** by cloning `Enterprise Code Quality Standards` project
1. **Create a GitLab issue** `Review and Apply Style` with the prompt content from the library file `.gitlab/workflows/java-style-workflow.md`
1. **In the issue** `Review and Apply Style` configure the workflow variables as detailed in the [Configuration section](#configuration-guide)
1. **In your VS code** with the project `Enterprise Code Quality Standards`, start the Duo Workflow with a simple [workflow prompt](#example-duo-workflow-prompt)
1. **Work with the Duo Workflow** by reviewing the proposed plan and automated tasks, if needed add further input to the workflow
1. **Review and commit** the styled code changes to your repository
### Example Duo Workflow Prompt
```yaml
Follow the instructions in issue <issue_reference_id> for the file <path/file_name.java>. Make sure to access any issues or GitLab projects mentioned in the issue to retrieve all necessary information.
```
This simple prompt is powerful because it instructs Duo Workflow to:
1. Read the detailed requirements in a specific issue ID
1. Access the referenced style guide repository
1. Apply the guidelines to the specified file
1. Follow all instructions in the issue
## Configuration Guide
The prompt is defined in the `.gitlab/workflows/java-style-workflow.md` file in the solution package. This file serves as your template for creating GitLab issues that instruct the workflow agent to build out the plan to automate the style guide review on your application and apply the changes.
In the first section of `.gitlab/workflows/java-style-workflow.md`, it defines variables you need to configure for the prompt.
### Variable Definition
The variables are defined directly in the `.gitlab/workflows/java-style-workflow.md` file. This file serves as your template for creating GitLab issues that instruct the AI assistant. You'll modify the variables in this file before creating a new issue with its contents.
#### 1. Style Guide Repository as the Context
The prompt must be configured to point to your organization's style guide repository. In the `java-style-prompt.md` file, replace the following variables:
- `{{GITLAB_INSTANCE}}`: Your GitLab instance URL (for example, `https://gitlab.example.com`)
- `{{STYLE_GUIDE_PROJECT_ID}}`: The GitLab project ID containing your Java style guide
- `{{STYLE_GUIDE_PROJECT_NAME}}`: The display name for your style guide project
- `{{STYLE_GUIDE_BRANCH}}`: The branch containing the most up-to-date style guide (default: main)
- `{{STYLE_GUIDE_PATH}}`: The path to the style guide document within the repository
Example:
```yaml
GITLAB_INSTANCE=https://gitlab.example.com
STYLE_GUIDE_PROJECT_ID=gl-demo-ultimate-zhenderson/sandbox/enterprise-java-standards
STYLE_GUIDE_PROJECT_NAME=Enterprise Java Standards
STYLE_GUIDE_BRANCH=main
STYLE_GUIDE_PATH=coding-style/java/guidelines/java-coding-standards.md
```
#### 2. Target Repository to Apply Style Improvement
In the same `java-style-prompt.md` file, configure which files to apply the style guide to:
- `{{TARGET_PROJECT_ID}}`: Your Java project's GitLab ID
- `{{TARGET_FILES}}`: Specific files or patterns to target (for example, "src/main/java/**/*.java")
Example:
```yaml
TARGET_PROJECT_ID=royal-reserve-bank
TARGET_FILES=asset-management-api/src/main/java/com/royal/reserve/bank/asset/management/api/service/AssetManagementService.java
```
### Important Notes About AI-Generated Code
**⚠️ Important Disclaimer**:
GitLab Workflow uses Agentic AI which is non-deterministic, meaning:
- Results may vary between runs even with identical inputs
- The AI assistant's understanding and application of style guidelines may differ slightly each time
- The examples provided in this documentation are illustrative and your actual results may differ
**Best Practices for Working with AI-Generated Code Changes**:
1. **Always review generated code**: Never merge AI-generated changes without thorough human review
1. **Follow proper merge request processes**: Use your standard code review procedures
1. **Run all tests**: Ensure all unit and integration tests pass before merging
1. **Verify style compliance**: Confirm the changes align with your style guide expectations
1. **Incremental application**: Consider applying style changes to smaller sets of files initially
Remember that this tool is meant to assist developers, not replace human judgment in the code review process.
## Step-by-Step Implementation
1. **Create a Style Guide Issue**
- Create a new issue in your project (for example, Issue #3)
- Include detailed information about the style guidelines to apply
- Reference the external style guide repository if applicable
- Specify requirements like:
```yaml
Task: Code Style Update
Description: Apply the enterprise standard Java style guidelines to the codebase.
Reference Style Guide: Enterprise Java Style Guidelines (https://gitlab.com/gl-demo-ultimate-zhenderson/sandbox/enterprise-java-standards/-/blob/main/coding-style/java/guidelines/java-coding-standards.md)
Constraints:
- Adhere to Enterprise Standard Java Style Guide
- Maintain Functionality
- Implement automated style checks
```
1. **Configure the Prompt**
- Copy the template from `java-style-prompt.md`
- Fill in all configuration variables
- Add any project-specific exceptions or requirements
1. **Execute via GitLab Workflow**
- Submit the configured prompt to Duo Workflow
- Duo Workflow will run through a multi-step process as seen in the sample workflow execution:
- Plan the task with specific tools (`run_read_only_git_command`, `read_file`, `find_files`, `edit_file`)
- Access the referenced issue
- Retrieve the enterprise Java style guide
- Analyze the current code structure
- Apply the style guidelines to the specified file(s)
- Verify the changes maintain functionality
- Provide a detailed report of changes made
1. **Review and Implement**
- Review the suggested changes
- Implement the changes in your codebase
- Run tests to ensure functionality is preserved
- Monitor the task progression through the GitLab Workflow interface
## Sample Workflow Execution
When properly configured, the GitLab Workflow will execute a detailed plan for applying the style guidelines. Here's a sample of what the workflow execution looks like:
### Sample Workflow Plan
The AI assistant first creates an execution plan with specific tools:
1. Access the Java style guidelines by retrieving content from Enterprise Java Standards project using `run_read_only_git_command` on `https://gitlab.com/gl-demo-ultimate-zhenderson/sandbox/enterprise-java-standards.git` for file `coding-style/java/guidelines/java-coding-standards.md`, supported by: `run_read_only_git_command`
1. Read and analyze the current content of `AssetManagementService.java` using the `read_file` tool to understand its structure and identify areas that need style updates, supported by `read_file`
1. Search for any similar files in the project using find_files to ensure consistent style application across related service classes, supported by `find_files`
1. Edit AssetManagementService.java using the edit_file tool to apply the style guidelines, focusing on:
- Package and import organization
- Class and method documentation
- Code indentation and spacing
- Annotation placement
- Method parameter formatting, supported by `edit_file`
1. Verify all Lombok annotations (@Service, @RequiredArgsConstructor, @Slf4j) are properly formatted according to the style guide using grep_files to check annotation patterns across the codebase, supported by `grep_files`
### Sample Analysis Output
The assistant then analyzes the files and requirements:
I've analyzed issue #3 and the `AssetManagementService.java` file. Here's what I found:
1. Issue #3 is about applying enterprise standard Java style guidelines to the Royal Banking codebase.
1. The `AssetManagementService.java` file is located in the `asset-management-api` module.
1. The style guidelines are stored in a separate GitLab project at `gl-demo-ultimate-zhenderson/sandbox/enterprise-java-standards`.
1. The current `AssetManagementService.java` file contains:
1. Package and import statements
1. Service class with Spring annotations
1. One public method for checking asset availability
1. Lombok annotations
1. Javadoc comments
The issue requires:
1. Formatting according to enterprise standard Java style guidelines
1. Implementation of automated style checks
1. Maintaining existing functionality
1. Ensuring all tests pass after style updates
To proceed with the implementation, you'll need to:
1. Access the Java style guidelines from the Enterprise Java Standards project
1. Apply the style guidelines to AssetManagementService.java
1. Verify that the changes don't affect functionality
1. Ensure all tests pass after the updates
### Sample Implementation Result
After execution, the assistant provides the transformed code with explanations of the changes made, including:
1. A summary of style guidelines applied
1. The transformed code with proper formatting
1. Explanations for key style changes
1. Recommendations for automated style enforcement
The changes typically include:
- Standardized import ordering
- Consistent spacing around operators
- Proper Javadoc formatting
- Standardized method parameter alignment
- Consistent brace placement
All while ensuring the code maintains its original functionality.
## Sample Tutorial Use Case: Royal Reserve Bank Java Project
This repository includes a banking tutorial example to demonstrate how the style guide application works in a real-world scenario. The Royal Reserve Bank project follows a microservices architecture with multiple Java services:
- Account API
- Asset Management API
- Transaction API
- Notification API
- API Gateway
- Config Server
- Discovery Server
The sample examples applies enterprise style guidelines to the `AssetManagementService.java` class, demonstrating proper formatting for:
1. Import organization
1. Javadoc standards
1. Method parameter alignment
1. Variable naming conventions
1. Exception handling patterns
## Customizing for Your Organization
To adapt this prompt for your organization's needs:
1. **Style Guide Replacement**
- Point to your organization's style guide repository
- Reference your specific style guide document
1. **Target File Selection**
- Choose specific files or patterns to apply the style guide to
- Prioritize high-visibility code files for initial implementation
1. **Additional Validation**
- Add custom validation requirements
- Specify any exceptions to the standard style rules
1. **Integration with CI/CD**
- Configure the prompt to run as part of your CI/CD pipeline
- Set up automated style checks to ensure ongoing compliance
## Troubleshooting
Common issues and their solutions:
- **Access Denied**: Ensure the AI agent has proper permissions to access both repositories
- **Missing Style Guide**: Verify the style guide path and branch are correct
- **Functionality Changes**: Run all tests after applying style changes to verify functionality
## Contributing
Feel free to enhance this prompt by:
- Adding more style rule explanations
- Creating examples for different Java project types
- Improving the validation workflow
- Adding integration with additional static analysis tools
|
---
stage: Solutions Architecture
group: Solutions Architecture
info: This page is owned by the Solutions Architecture team.
title: Duo Workflow Use Case for Applying Coding Style
breadcrumbs:
- doc
- solutions
- components
- duo_workflow
---
{{< details >}}
- Tier: Ultimate with GitLab Duo Workflow
- Offering: GitLab.com
- Status: Experiment
{{< /details >}}
## Getting Started
### Download the Solution Component
1. Obtain the invitation code from your account team.
1. Download the solution component from [the solution component webstore](https://cloud.gitlab-accelerator-marketplace.com) by using your invitation code.
## Duo Workflow Use Case: Improve Java Application with Style Guide
The document describes GitLab Duo Workflow Solution with prompt and context library. The purpose of the solution is to improve appliction coding based on defined style.
This solution provides a GitLab issue as the prompt and the style guide as the context, designed to automate Java style guidelines to codebases using GitLab Duo Workflow. The prompt and context library enables Duo Workflow to:
1. Access centralized style guide content stored in GitLab repository,
1. Understand domain-specific coding standards, and
1. Apply consistent formatting to Java code while preserving functionality.
For detailed information about GitLab Duo Workflow, review [the document here](../../../user/duo_workflow/_index.md).
### Key Benefits
- **Enforces consistent style** across all Java codebases
- **Automates style application** without manual effort
- **Maintains code functionality** while improving readability
- **Integrates with GitLab Workflow** for seamless implementation
- **Reduces code review time** spent addressing style issues
- **Serves as a learning tool** for developers to understand style guidelines
### Sample Result
When properly configured, the prompt will transform your code to match enterprise standards, similar to the transformation shown in this diff:
## Configure the Solution Prompt and Context Library
### Basic Setup
To run the agentic workflow to review and apply style to your application, you need to set up this use case prompt and context library.
1. **Set up the prompt and contet library** by cloning `Enterprise Code Quality Standards` project
1. **Create a GitLab issue** `Review and Apply Style` with the prompt content from the library file `.gitlab/workflows/java-style-workflow.md`
1. **In the issue** `Review and Apply Style` configure the workflow variables as detailed in the [Configuration section](#configuration-guide)
1. **In your VS code** with the project `Enterprise Code Quality Standards`, start the Duo Workflow with a simple [workflow prompt](#example-duo-workflow-prompt)
1. **Work with the Duo Workflow** by reviewing the proposed plan and automated tasks, if needed add further input to the workflow
1. **Review and commit** the styled code changes to your repository
### Example Duo Workflow Prompt
```yaml
Follow the instructions in issue <issue_reference_id> for the file <path/file_name.java>. Make sure to access any issues or GitLab projects mentioned in the issue to retrieve all necessary information.
```
This simple prompt is powerful because it instructs Duo Workflow to:
1. Read the detailed requirements in a specific issue ID
1. Access the referenced style guide repository
1. Apply the guidelines to the specified file
1. Follow all instructions in the issue
## Configuration Guide
The prompt is defined in the `.gitlab/workflows/java-style-workflow.md` file in the solution package. This file serves as your template for creating GitLab issues that instruct the workflow agent to build out the plan to automate the style guide review on your application and apply the changes.
In the first section of `.gitlab/workflows/java-style-workflow.md`, it defines variables you need to configure for the prompt.
### Variable Definition
The variables are defined directly in the `.gitlab/workflows/java-style-workflow.md` file. This file serves as your template for creating GitLab issues that instruct the AI assistant. You'll modify the variables in this file before creating a new issue with its contents.
#### 1. Style Guide Repository as the Context
The prompt must be configured to point to your organization's style guide repository. In the `java-style-prompt.md` file, replace the following variables:
- `{{GITLAB_INSTANCE}}`: Your GitLab instance URL (for example, `https://gitlab.example.com`)
- `{{STYLE_GUIDE_PROJECT_ID}}`: The GitLab project ID containing your Java style guide
- `{{STYLE_GUIDE_PROJECT_NAME}}`: The display name for your style guide project
- `{{STYLE_GUIDE_BRANCH}}`: The branch containing the most up-to-date style guide (default: main)
- `{{STYLE_GUIDE_PATH}}`: The path to the style guide document within the repository
Example:
```yaml
GITLAB_INSTANCE=https://gitlab.example.com
STYLE_GUIDE_PROJECT_ID=gl-demo-ultimate-zhenderson/sandbox/enterprise-java-standards
STYLE_GUIDE_PROJECT_NAME=Enterprise Java Standards
STYLE_GUIDE_BRANCH=main
STYLE_GUIDE_PATH=coding-style/java/guidelines/java-coding-standards.md
```
#### 2. Target Repository to Apply Style Improvement
In the same `java-style-prompt.md` file, configure which files to apply the style guide to:
- `{{TARGET_PROJECT_ID}}`: Your Java project's GitLab ID
- `{{TARGET_FILES}}`: Specific files or patterns to target (for example, "src/main/java/**/*.java")
Example:
```yaml
TARGET_PROJECT_ID=royal-reserve-bank
TARGET_FILES=asset-management-api/src/main/java/com/royal/reserve/bank/asset/management/api/service/AssetManagementService.java
```
### Important Notes About AI-Generated Code
**⚠️ Important Disclaimer**:
GitLab Workflow uses Agentic AI which is non-deterministic, meaning:
- Results may vary between runs even with identical inputs
- The AI assistant's understanding and application of style guidelines may differ slightly each time
- The examples provided in this documentation are illustrative and your actual results may differ
**Best Practices for Working with AI-Generated Code Changes**:
1. **Always review generated code**: Never merge AI-generated changes without thorough human review
1. **Follow proper merge request processes**: Use your standard code review procedures
1. **Run all tests**: Ensure all unit and integration tests pass before merging
1. **Verify style compliance**: Confirm the changes align with your style guide expectations
1. **Incremental application**: Consider applying style changes to smaller sets of files initially
Remember that this tool is meant to assist developers, not replace human judgment in the code review process.
## Step-by-Step Implementation
1. **Create a Style Guide Issue**
- Create a new issue in your project (for example, Issue #3)
- Include detailed information about the style guidelines to apply
- Reference the external style guide repository if applicable
- Specify requirements like:
```yaml
Task: Code Style Update
Description: Apply the enterprise standard Java style guidelines to the codebase.
Reference Style Guide: Enterprise Java Style Guidelines (https://gitlab.com/gl-demo-ultimate-zhenderson/sandbox/enterprise-java-standards/-/blob/main/coding-style/java/guidelines/java-coding-standards.md)
Constraints:
- Adhere to Enterprise Standard Java Style Guide
- Maintain Functionality
- Implement automated style checks
```
1. **Configure the Prompt**
- Copy the template from `java-style-prompt.md`
- Fill in all configuration variables
- Add any project-specific exceptions or requirements
1. **Execute via GitLab Workflow**
- Submit the configured prompt to Duo Workflow
- Duo Workflow will run through a multi-step process as seen in the sample workflow execution:
- Plan the task with specific tools (`run_read_only_git_command`, `read_file`, `find_files`, `edit_file`)
- Access the referenced issue
- Retrieve the enterprise Java style guide
- Analyze the current code structure
- Apply the style guidelines to the specified file(s)
- Verify the changes maintain functionality
- Provide a detailed report of changes made
1. **Review and Implement**
- Review the suggested changes
- Implement the changes in your codebase
- Run tests to ensure functionality is preserved
- Monitor the task progression through the GitLab Workflow interface
## Sample Workflow Execution
When properly configured, the GitLab Workflow will execute a detailed plan for applying the style guidelines. Here's a sample of what the workflow execution looks like:
### Sample Workflow Plan
The AI assistant first creates an execution plan with specific tools:
1. Access the Java style guidelines by retrieving content from Enterprise Java Standards project using `run_read_only_git_command` on `https://gitlab.com/gl-demo-ultimate-zhenderson/sandbox/enterprise-java-standards.git` for file `coding-style/java/guidelines/java-coding-standards.md`, supported by: `run_read_only_git_command`
1. Read and analyze the current content of `AssetManagementService.java` using the `read_file` tool to understand its structure and identify areas that need style updates, supported by `read_file`
1. Search for any similar files in the project using find_files to ensure consistent style application across related service classes, supported by `find_files`
1. Edit AssetManagementService.java using the edit_file tool to apply the style guidelines, focusing on:
- Package and import organization
- Class and method documentation
- Code indentation and spacing
- Annotation placement
- Method parameter formatting, supported by `edit_file`
1. Verify all Lombok annotations (@Service, @RequiredArgsConstructor, @Slf4j) are properly formatted according to the style guide using grep_files to check annotation patterns across the codebase, supported by `grep_files`
### Sample Analysis Output
The assistant then analyzes the files and requirements:
I've analyzed issue #3 and the `AssetManagementService.java` file. Here's what I found:
1. Issue #3 is about applying enterprise standard Java style guidelines to the Royal Banking codebase.
1. The `AssetManagementService.java` file is located in the `asset-management-api` module.
1. The style guidelines are stored in a separate GitLab project at `gl-demo-ultimate-zhenderson/sandbox/enterprise-java-standards`.
1. The current `AssetManagementService.java` file contains:
1. Package and import statements
1. Service class with Spring annotations
1. One public method for checking asset availability
1. Lombok annotations
1. Javadoc comments
The issue requires:
1. Formatting according to enterprise standard Java style guidelines
1. Implementation of automated style checks
1. Maintaining existing functionality
1. Ensuring all tests pass after style updates
To proceed with the implementation, you'll need to:
1. Access the Java style guidelines from the Enterprise Java Standards project
1. Apply the style guidelines to AssetManagementService.java
1. Verify that the changes don't affect functionality
1. Ensure all tests pass after the updates
### Sample Implementation Result
After execution, the assistant provides the transformed code with explanations of the changes made, including:
1. A summary of style guidelines applied
1. The transformed code with proper formatting
1. Explanations for key style changes
1. Recommendations for automated style enforcement
The changes typically include:
- Standardized import ordering
- Consistent spacing around operators
- Proper Javadoc formatting
- Standardized method parameter alignment
- Consistent brace placement
All while ensuring the code maintains its original functionality.
## Sample Tutorial Use Case: Royal Reserve Bank Java Project
This repository includes a banking tutorial example to demonstrate how the style guide application works in a real-world scenario. The Royal Reserve Bank project follows a microservices architecture with multiple Java services:
- Account API
- Asset Management API
- Transaction API
- Notification API
- API Gateway
- Config Server
- Discovery Server
The sample examples applies enterprise style guidelines to the `AssetManagementService.java` class, demonstrating proper formatting for:
1. Import organization
1. Javadoc standards
1. Method parameter alignment
1. Variable naming conventions
1. Exception handling patterns
## Customizing for Your Organization
To adapt this prompt for your organization's needs:
1. **Style Guide Replacement**
- Point to your organization's style guide repository
- Reference your specific style guide document
1. **Target File Selection**
- Choose specific files or patterns to apply the style guide to
- Prioritize high-visibility code files for initial implementation
1. **Additional Validation**
- Add custom validation requirements
- Specify any exceptions to the standard style rules
1. **Integration with CI/CD**
- Configure the prompt to run as part of your CI/CD pipeline
- Set up automated style checks to ensure ongoing compliance
## Troubleshooting
Common issues and their solutions:
- **Access Denied**: Ensure the AI agent has proper permissions to access both repositories
- **Missing Style Guide**: Verify the style guide path and branch are correct
- **Functionality Changes**: Run all tests after applying style changes to verify functionality
## Contributing
Feel free to enhance this prompt by:
- Adding more style rule explanations
- Creating examples for different Java project types
- Improving the validation workflow
- Adding integration with additional static analysis tools
|
https://docs.gitlab.com/solutions/components/duo_workflow
|
https://gitlab.com/gitlab-org/gitlab/-/tree/master/doc/solutions/components/_index.md
|
2025-08-13
|
doc/solutions/components/duo_workflow
|
[
"doc",
"solutions",
"components",
"duo_workflow"
] |
_index.md
|
Solutions Architecture
|
Solutions Architecture
|
This page is owned by the Solutions Architecture team.
|
GitLab AI Solution Components
| null |
This documentation section covers a variety of Solution components developed and provided by GitLab.
To download and run these solution components, request your account team for invitation code.
The use of any Solution component is subject to the [GitLab Subscription Agreement](https://handbook.gitlab.com/handbook/legal/subscription-agreement/) (the "Agreement") and constitutes Free Software as defined within the Agreement.
## GitLab Duo Workflow
GitLab Duo Workflow helps you complete development tasks. The GitLab codebase, issues, merge requests and pipelines can be the context where the agentic workflow can be carried out from the prompt using the VS Code integrated development environment (IDE).
For detailed information about GitLab Duo Workflow, review [the document here](../../../user/duo_workflow/_index.md).
## Duo Workflow Solution
The Duo Workflow Solution provides prompt and context library for different software development use cases. Each solution use case with the prompt and context library support the desired automous workflow to automate the development tasks, including tasks ranged from coding changes, problem fixing and code review based on the defined workflow plan.
[Agentic Workflow: Apply Coding Style Guide](duo_workflow_codestyle.md)
|
---
stage: Solutions Architecture
group: Solutions Architecture
info: This page is owned by the Solutions Architecture team.
title: GitLab AI Solution Components
breadcrumbs:
- doc
- solutions
- components
- duo_workflow
---
This documentation section covers a variety of Solution components developed and provided by GitLab.
To download and run these solution components, request your account team for invitation code.
The use of any Solution component is subject to the [GitLab Subscription Agreement](https://handbook.gitlab.com/handbook/legal/subscription-agreement/) (the "Agreement") and constitutes Free Software as defined within the Agreement.
## GitLab Duo Workflow
GitLab Duo Workflow helps you complete development tasks. The GitLab codebase, issues, merge requests and pipelines can be the context where the agentic workflow can be carried out from the prompt using the VS Code integrated development environment (IDE).
For detailed information about GitLab Duo Workflow, review [the document here](../../../user/duo_workflow/_index.md).
## Duo Workflow Solution
The Duo Workflow Solution provides prompt and context library for different software development use cases. Each solution use case with the prompt and context library support the desired automous workflow to automate the development tasks, including tasks ranged from coding changes, problem fixing and code review based on the defined workflow plan.
[Agentic Workflow: Apply Coding Style Guide](duo_workflow_codestyle.md)
|
https://docs.gitlab.com/solutions/components/duo_workflow_gendoc
|
https://gitlab.com/gitlab-org/gitlab/-/tree/master/doc/solutions/components/duo_workflow_gendoc.md
|
2025-08-13
|
doc/solutions/components/duo_workflow
|
[
"doc",
"solutions",
"components",
"duo_workflow"
] |
duo_workflow_gendoc.md
|
Solutions Architecture
|
Solutions Architecture
|
This page is owned by the Solutions Architecture team.
|
Duo Workflow Use Case for Generating Documentation
| null |
{{< details >}}
- Tier: Ultimate with GitLab Duo Workflow
- Offering: GitLab.com
- Status: Experiment
{{< /details >}}
## Getting Started
### Download the Solution Component
1. Obtain the invitation code from your account team.
1. Download the solution component from [the solution component webstore](https://cloud.gitlab-accelerator-marketplace.com) by using your invitation code.
|
---
stage: Solutions Architecture
group: Solutions Architecture
info: This page is owned by the Solutions Architecture team.
title: Duo Workflow Use Case for Generating Documentation
breadcrumbs:
- doc
- solutions
- components
- duo_workflow
---
{{< details >}}
- Tier: Ultimate with GitLab Duo Workflow
- Offering: GitLab.com
- Status: Experiment
{{< /details >}}
## Getting Started
### Download the Solution Component
1. Obtain the invitation code from your account team.
1. Download the solution component from [the solution component webstore](https://cloud.gitlab-accelerator-marketplace.com) by using your invitation code.
|
https://docs.gitlab.com/solutions/languages
|
https://gitlab.com/gitlab-org/gitlab/-/tree/master/doc/solutions/_index.md
|
2025-08-13
|
doc/solutions/languages
|
[
"doc",
"solutions",
"languages"
] |
_index.md
|
Solutions Architecture
|
Solutions Architecture
|
This page is owned by the Solutions Architecture team.
|
Coding Languages and Frameworks
| null |
This section provides resource indexes and enablements around individual coding languages including any ecosystem technologies that surround them (for example, dependency packaging frameworks)
## Solutions categories
[Rust Language Solutions](rust/_index.md)
|
---
stage: Solutions Architecture
group: Solutions Architecture
info: This page is owned by the Solutions Architecture team.
title: Coding Languages and Frameworks
breadcrumbs:
- doc
- solutions
- languages
---
This section provides resource indexes and enablements around individual coding languages including any ecosystem technologies that surround them (for example, dependency packaging frameworks)
## Solutions categories
[Rust Language Solutions](rust/_index.md)
|
https://docs.gitlab.com/solutions/languages/rust
|
https://gitlab.com/gitlab-org/gitlab/-/tree/master/doc/solutions/languages/_index.md
|
2025-08-13
|
doc/solutions/languages/rust
|
[
"doc",
"solutions",
"languages",
"rust"
] |
_index.md
|
Solutions Architecture
|
Solutions Architecture
|
This page is owned by the Solutions Architecture team.
|
Rust Language and Ecosystem Solutions Index
| null |
This page attempts to index the ways in which GitLab supports Rust. It does so whether the integration is the result of configuring general functionality, was built in to Rust or GitLab or is provided as a solution.
Unless otherwise noted, all of this content applies to both GitLab.com and GitLab Self-Managed instances.
| Text Tag | Configuration / Built / Solution | Support/Maintenance |
| ------------------------ | ------------------------------------------------------------ | ------------------------------------------------------------ |
| `[Rust Configuration]` | Integration accomplished by Configuring Existing Rust Functionality | Rust |
| `[GitLab Configuration]` | Integration accomplished by Configuring Existing GitLab Functionality | GitLab |
| `[Rust Partner Built]` | Built into GitLab by Product Team to Address Rust Integration | GitLab |
| `[Rust Partner Solution]` | Built as Solution Example by Rust or Rust Partners | Community/Example |
| `[GitLab Solution]` | Built as Solution Example by GitLab or GitLab Partners | Community/Example |
| `[CI Solution]` | Built using GitLab CI and therefore <br />more customer customizable. | Items tagged `[CI Solution]` will <br />also carry one of the other tags <br />that indicate the maintenance status. |
## Rust SCM
- [GitLab Duo Code Suggestions](../../../user/project/repository/code_suggestions/supported_extensions.md#supported-languages-by-ide) `[GitLab Built]`
## Rust CI
- [Unit Testing Results](../../../ci/testing/unit_test_report_examples.md#rust) `[GitLab Built]`
- [GitLab CICD Rust Component](https://gitlab.com/explore/catalog/components/rust) `[GitLab Built]`
- [Using Rust Component](../../../ci/components/examples.md#example-test-a-rust-language-cicd-component) `[GitLab Built]`
## Rust CD
- GitLab package registry Support for Cargo - [Open for Contributions](https://gitlab.com/gitlab-org/gitlab/-/issues/33060)
- [GitLab CICD Rust Component (Currently in Prerelease)](https://gitlab.com/explore/catalog/components/rust) `[GitLab Built]`
- [How To Use the Rust Component](../../../ci/components/examples.md#example-test-a-rust-language-cicd-component) `[GitLab Built]`
## Rust Security and SBOM
- [Testing Code Coverage](../../../ci/testing/code_coverage/_index.md#coverage-regex-patterns) `[GitLab Built]`
- [GitLab SAST Scanning](../../../user/application_security/sast/_index.md#supported-languages-and-frameworks) `[GitLab Built]`- requires custom ruleset be created.
- [Rust License Scanning (Currently in Prerelease)](https://gitlab.com/groups/gitlab-org/-/epics/13093) `[GitLab Built]`
- [CodeSecure CodeSonar Embedded C Deep SAST Scanner as a GitLab CI/CD Component](https://gitlab.com/explore/catalog/codesonar/components/codesonar-ci) `[Rust Partner Built]` `[CI Solution]` - supports deep Abstract Execution analysis by watching compiles. Supports GitLabs SAST JSON which enables the findings throughout GitLab Ultimate security features. Features MISRA support and direct support for many Embedded Systems compilers.
|
---
stage: Solutions Architecture
group: Solutions Architecture
info: This page is owned by the Solutions Architecture team.
title: Rust Language and Ecosystem Solutions Index
breadcrumbs:
- doc
- solutions
- languages
- rust
---
This page attempts to index the ways in which GitLab supports Rust. It does so whether the integration is the result of configuring general functionality, was built in to Rust or GitLab or is provided as a solution.
Unless otherwise noted, all of this content applies to both GitLab.com and GitLab Self-Managed instances.
| Text Tag | Configuration / Built / Solution | Support/Maintenance |
| ------------------------ | ------------------------------------------------------------ | ------------------------------------------------------------ |
| `[Rust Configuration]` | Integration accomplished by Configuring Existing Rust Functionality | Rust |
| `[GitLab Configuration]` | Integration accomplished by Configuring Existing GitLab Functionality | GitLab |
| `[Rust Partner Built]` | Built into GitLab by Product Team to Address Rust Integration | GitLab |
| `[Rust Partner Solution]` | Built as Solution Example by Rust or Rust Partners | Community/Example |
| `[GitLab Solution]` | Built as Solution Example by GitLab or GitLab Partners | Community/Example |
| `[CI Solution]` | Built using GitLab CI and therefore <br />more customer customizable. | Items tagged `[CI Solution]` will <br />also carry one of the other tags <br />that indicate the maintenance status. |
## Rust SCM
- [GitLab Duo Code Suggestions](../../../user/project/repository/code_suggestions/supported_extensions.md#supported-languages-by-ide) `[GitLab Built]`
## Rust CI
- [Unit Testing Results](../../../ci/testing/unit_test_report_examples.md#rust) `[GitLab Built]`
- [GitLab CICD Rust Component](https://gitlab.com/explore/catalog/components/rust) `[GitLab Built]`
- [Using Rust Component](../../../ci/components/examples.md#example-test-a-rust-language-cicd-component) `[GitLab Built]`
## Rust CD
- GitLab package registry Support for Cargo - [Open for Contributions](https://gitlab.com/gitlab-org/gitlab/-/issues/33060)
- [GitLab CICD Rust Component (Currently in Prerelease)](https://gitlab.com/explore/catalog/components/rust) `[GitLab Built]`
- [How To Use the Rust Component](../../../ci/components/examples.md#example-test-a-rust-language-cicd-component) `[GitLab Built]`
## Rust Security and SBOM
- [Testing Code Coverage](../../../ci/testing/code_coverage/_index.md#coverage-regex-patterns) `[GitLab Built]`
- [GitLab SAST Scanning](../../../user/application_security/sast/_index.md#supported-languages-and-frameworks) `[GitLab Built]`- requires custom ruleset be created.
- [Rust License Scanning (Currently in Prerelease)](https://gitlab.com/groups/gitlab-org/-/epics/13093) `[GitLab Built]`
- [CodeSecure CodeSonar Embedded C Deep SAST Scanner as a GitLab CI/CD Component](https://gitlab.com/explore/catalog/codesonar/components/codesonar-ci) `[Rust Partner Built]` `[CI Solution]` - supports deep Abstract Execution analysis by watching compiles. Supports GitLabs SAST JSON which enables the findings throughout GitLab Ultimate security features. Features MISRA support and direct support for many Embedded Systems compilers.
|
https://docs.gitlab.com/solutions/aws_googlecloud_ollama
|
https://gitlab.com/gitlab-org/gitlab/-/tree/master/doc/solutions/aws_googlecloud_ollama.md
|
2025-08-13
|
doc/solutions/integrations
|
[
"doc",
"solutions",
"integrations"
] |
aws_googlecloud_ollama.md
|
Solutions Architecture
|
Solutions Architecture
|
This page is owned by the Solutions Architecture team.
|
GitLab Duo Self-Hosted: Complete AWS/Google Cloud Deployment Guide with Ollama Integration
| null |
{{< details >}}
- Tier: Ultimate
- Add-on: GitLab Duo Pro or Enterprise
- Offering: GitLab Self-Managed
{{< /details >}}
The document describes the installation and integration of GitLab and GitLab Duo with a self-hosted Large Language Model (LLM) running a Mistral model on Ollama. The guide describes the setup using 3 different
virtual machines and can be easily followed along on AWS or GCP. Of course, the process is applicable to different deployment platforms, too.
This guide is a comprehensive, end-to-end set of instructions for getting the desired setup working. It calls out references to the many areas of GitLab documentation that were used to support the creation of the final configuration. The referenced docs are important when more background is needed to adjust the implementation to a specific scenario.
<!-- TOC -->
- GitLab Duo Self-Hosted: Complete AWS/Google Cloud Deployment Guide with Ollama Integration
- [Prerequisites](#prerequisites)
- [Virtual Machines](#virtual-machines)
- [Resources & Operating System](#resources--operating-system)
- [Networking](#networking)
- [GitLab](#gitlab)
- [Licensing](#licensing)
- [SSL/TLS](#ssltls)
- [Introduction](#introduction)
- [Installation](#installation)
- [AI Gateway](#ai-gateway)
- [Ollama](#ollama)
- [Installation](#installation)
- [Model Deployment](#model-deployment)
- [Integration](#integration)
- [Enable GitLab Duo for Root User](#enable-gitlab-duo-for-root-user)
- [Configure Self-Hosted Model in GitLab](#configure-gitlab-duo-self-hosted-in-gitlab)
- [Verification](#verification)
<!-- /TOC -->
## Prerequisites
### Virtual Machines
#### Resources & Operating System
We will install GitLab, GitLab AI Gateway and Ollama each in their own separate virtual machine. While we used Ubuntu 24.0x in this guide, you have flexibility in choosing any Unix-based operating system that meets your organization's requirements and preferences. However, using a Unix-based operating system is mandatory for this setup. This ensures system stability, security, and compatibility with the required software stack. This setup provides a good balance between cost and performance for testing and evaluation phases, though you may need to upgrade the GPU instance type when moving to production, depending on your usage requirements and team size.
| | **GCP** | **AWS** | **OS** | **Disk** |
|----------------|---------------|-------------|-----------|----------|
| **GitLab** | c2-standard-4 | c6xlarge | Ubuntu 24 | 50 GB |
| **AI Gateway** | e2-medium | t2.medium | Ubuntu 24 | 20 GB |
| **Ollama** | n1-standard-4 | g4dn.xlarge | Ubuntu 24 | 50 GB |
For more information about the component and its purpose, see [AI Gateway](../../user/gitlab_duo/gateway.md).
```mermaid
%%{init: { "fontFamily": "GitLab Sans" }}%%
flowchart LR
accTitle: GitLab Duo Self-Hosted architecture
accDescr: Shows the flow from GitLab Ultimate to the AI gateway, which connects to Ollama running Mistral.
A[GitLab<br/>Ultimate] --> C
C[GitLab<br/>AI Gateway] --> B[Ollama<br/>Mistral]
```
These components work together to realize the Self-Hosted AI functionality. This guide provides detailed instructions for building a complete self-hosted AI environment using Ollama as the LLM server.
{{< alert type="note" >}}
While for a full production environment, the [official documentation](../../administration/gitlab_duo_self_hosted/supported_models_and_hardware_requirements.md) recommends more powerful GPU instances such as 1x NVIDIA A100 (40 GB), the g4dn.xlarge instance type should be sufficient for evaluation purposes with a small team of users.
{{< /alert >}}
#### Networking
To enable access to GitLab, a static public IP address (such as an Elastic IP in AWS or an External IP in Google Cloud) is required. All other components can and should use static internal IP addresses for internal communication. We assume all VMs are on the same network and can communicate directly.
| | **Public IP** | **Private IP** |
|----------------|---------------|----------------|
| **GitLab** | yes | yes |
| **AI Gateway** | no | yes |
| **Ollama** | no | yes |
Why Use Internal IPs?
- Internal IPs remain static throughout an instance's lifetime in AWS/Google Cloud.
- Only the GitLab server needs external access, while other components, like Ollama, rely on internal communication.
- This approach reduces costs by avoiding charges for public IP addresses and enhances security by keeping the LLM server inaccessible from the internet.
### GitLab
The rest of this guide assumes you already have an instance of GitLab up and running that meets the following requirements:
#### Licensing
Operating GitLab Duo Self-Hosted requires both a GitLab Ultimate license and a GitLab Duo Enterprise license. The GitLab Ultimate license works with either online or offline licensing options. This documentation assumes that both licenses have been previously obtained and are available for implementation.
#### SSL/TLS
A valid SSL certificate (such as Let's Encrypt) must be configured for the GitLab instance. This is not just a security best practice, but a technical requirement because:
- The AI Gateway system (as of January 2025) strictly requires proper SSL verification when communicating with GitLab
- Self-signed certificates are not accepted by the AI Gateway
- Non-SSL connections (HTTP) are also not supported
GitLab provides a convenient automated SSL setup process:
- During the GitLab installation, simply specify your URL with "https://" prefix
- GitLab will automatically:
- Obtain a Let's Encrypt SSL certificate
- Install the certificate
- Configure HTTPS
- No manual SSL certificate management is required
During the installation of GitLab, the procedure looks something like this:
1. Allocate and associate public and static IP address with the GitLab instance
1. Configure your DNS records to point at that address
1. During GitLab installation, use your HTTPS URL (for example, `https://gitlab.yourdomain.com`)
1. Let GitLab handle the SSL certificate setup automatically
For details, refer to the [documentation](https://docs.gitlab.com/omnibus/settings/ssl/) page.
## Introduction
Before setting up GitLab Duo Self-Hosted, it's important to understand how AI works. AI model is the AI's brain trained with data. This brain needs a framework to operate, which is called an LLM Serving Platform or simply "Serving Platform." In AWS, this is "Amazon Bedrock," in Azure, it's "Azure OpenAI Service," and for ChatGPT, it's their platform. For Anthropic, it's "Claude.". For self-hosing models, Ollama is a common choice.
For example:
- In AWS, the serving platform is Amazon Bedrock.
- In Azure, it's the Azure OpenAI Service.
- For ChatGPT, it's OpenAI's proprietary platform
- For Anthropic, the serving platform is Claude.
When you host an AI model yourself, you'll also need to choose a serving platform. A popular option for self-hosted models is Ollama.
In this analogy, the brain part for ChatGPT is the GPT-4 model, while in the Anthropic ecosystem, it's the Claude 3.7 Sonnet model. The serving platform acts as the vital framework that connects the brain to the world, enabling it to "think" and interact effectively.
For further information about supported serving platforms and models, see [LLM Serving Platforms](../../administration/gitlab_duo_self_hosted/supported_llm_serving_platforms.md) and [Models](../../administration/gitlab_duo_self_hosted/supported_models_and_hardware_requirements.md).
**What is Ollama?**
Ollama is a streamlined, open-source framework for running Large Language Models (LLMs) in local environments. It simplifies the traditionally complex process of deploying AI models, making it accessible to both individuals and organizations looking for efficient, flexible, and scalable AI solutions.
Key Highlights:
1. **Simplified Deployment**: A user-friendly command-line interface ensures quick setup and hassle-free installation.
1. **Wide Model Support**: Compatible with popular open-source models like Llama 2, Mistral, and Code Llama.
1. **Optimized Performance**: Operates seamlessly across both GPU and CPU environments for resource efficiency.
1. **Integration-Ready**: Features an OpenAI-compatible API for easy integration with existing tools and workflows.
1. **No Containers Needed**: Runs directly on host systems, eliminating the need for Docker or containerized environments.
1. **Versatile Hosting Options**: Deployable on local machines, on-premises servers, or cloud GPU instances.
Designed for simplicity and performance, Ollama empowers users to harness the power of LLMs without the complexity of traditional AI infrastructure. Further details on setup and supported models will be covered later in the documentation.
- [Ollama Model Support](https://ollama.com/search)
## Installation
### AI Gateway
While the official installation guide is available in [Install the GitLab AI gateway](../../install/install_ai_gateway.md), here's a streamlined approach for setting up the AI Gateway. As of January
2025, the image `gitlab/model-gateway:self-hosted-v17.6.0-ee` has been verified to work with GitLab 17.7.
1. Ensure that ...
- TCP port 5052 to the API Gateway VM is permitted (check security group configuration)
- You replace `GITLAB_DOMAIN` with the domain name to YOUR instance of GitLab in the following code snippet:
1. Run the following command to start the GitLab AI Gateway:
```shell
GITLAB_DOMAIN="gitlab.yourdomain.com"
docker run -p 5052:5052 \
-e AIGW_GITLAB_URL=$GITLAB_DOMAIN \
-e AIGW_GITLAB_API_URL=https://${GITLAB_DOMAIN}/api/v4/ \
-e AIGW_AUTH__BYPASS_EXTERNAL=true \
gitlab/model-gateway:self-hosted-v17.6.0-ee
```
The following table explains key environment variables and their roles in setting up your instance:
| **Variable** | **Description** |
|------------------------------|-----------------|
| `AIGW_GITLAB_URL` | Your GitLab instance domain. |
| `AIGW_GITLAB_API_URL` | The API endpoint of your GitLab instance. |
| `AIGW_AUTH__BYPASS_EXTERNAL` | Configuration for handling authentication. |
During the initial setup and testing phase, you can set AIGW_AUTH__BYPASS_EXTERNAL=true to bypass authentication and avoid issues. However, this configuration should never be used in a production environment or on servers exposed to the internet.
### Ollama
#### Installation
1. Install Ollama using the official installation script:
```shell
curl --fail --silent --show-error --location "https://ollama.com/install.sh" | sh
```
1. Configure Ollama to listen on the internal IP by adding the `OLLAMA_HOST` environment variable to its startup configuration
```shell
systemctl edit ollama.service
```
```ini
[Service]
Environment="OLLAMA_HOST=172.31.11.27"
```
{{< alert type="note" >}}
Replace the IP address with your actual server's internal IP address.
{{< /alert >}}
1. Reload and restart the service:
```shell
systemctl daemon-reload
systemctl restart ollama
```
#### Model Deployment
1. Set the environment variable:
```shell
export OLLAMA_HOST=172.31.11.27
```
1. Install the Mistral Instruct model:
```shell
ollama pull mistral:instruct
```
The `mistral:instruct` model requires approximately 4.1 GB of storage space and will take a while to download depending on your connection speed.
1. Verify the model installation:
```shell
ollama list
```
The command should show the installed model in the list.
## Integration
### Enable GitLab Duo for Root User
1. Access the GitLab Web Interface
- Log in as the administrator user
- Navigate to the Admin Area (wrench icon)
1. Configure Duo License
- Go to the "Subscription" section in the left sidebar
- You should see "Seats used: 1/5" indicating available Duo seats
- Note: Only one seat is needed for the root user
1. Assign Duo License to Root
- Navigate to "Admin area" > "GitLab Duo" > "Seat utilization"
- Locate the root user (Administrator) in the user list
- Toggle the switch in the "GitLab Duo Enterprise" column to enable Duo for the root user
- The toggle button should turn blue when enabled
{{< alert type="note" >}}
Enabling Duo for just the root user is sufficient for initial setup and testing. Additional users can be granted Duo access later if needed, within your seat license limitations.
{{< /alert >}}
### Configure GitLab Duo Self-Hosted in GitLab
1. Access GitLab Duo Self-Hosted Configuration
- Navigate to Admin Area > GitLab Duo > "Configure GitLab Duo Self-hosted"
- Click "Add self-hosted model" button
1. Configure Model Settings
- **Deployment name**: Choose a descriptive name (for example `Mistral-7B-Instruct-v0.3 on AWS Tokyo`)
- **Model family**: Select "Mistral" from the dropdown list
- **Endpoint**: Enter your Ollama server URL in the format:
```plaintext
http://[Internal-IP]:11434/v1
```
Example: `http://172.31.11.27:11434/v1`
- **Model identifier**: Enter `custom_openai/mistral:instruct`
- **API Key**: Enter any placeholder text (for example, `test`) as this field cannot be left blank
1. Enable AI Features
- Navigate to the "AI-native features" tab
- Assign the configured model to the following features:
- Code Suggestions > Code Generation
- Code Suggestions > Code Completion
- GitLab Duo Chat > General Chat
- Select your deployed model from the dropdown list for each feature
These settings establish the connection between your GitLab instance and the self-hosted Ollama model through the AI Gateway, enabling AI-native features within GitLab.
## Verification
1. Create a test group in GitLab
1. The GitLab Duo Chat icon should appear in the top right corner
1. This indicates successful integration between GitLab and the AI Gateway
|
---
stage: Solutions Architecture
group: Solutions Architecture
info: This page is owned by the Solutions Architecture team.
title: 'GitLab Duo Self-Hosted: Complete AWS/Google Cloud Deployment Guide with Ollama
Integration'
breadcrumbs:
- doc
- solutions
- integrations
---
{{< details >}}
- Tier: Ultimate
- Add-on: GitLab Duo Pro or Enterprise
- Offering: GitLab Self-Managed
{{< /details >}}
The document describes the installation and integration of GitLab and GitLab Duo with a self-hosted Large Language Model (LLM) running a Mistral model on Ollama. The guide describes the setup using 3 different
virtual machines and can be easily followed along on AWS or GCP. Of course, the process is applicable to different deployment platforms, too.
This guide is a comprehensive, end-to-end set of instructions for getting the desired setup working. It calls out references to the many areas of GitLab documentation that were used to support the creation of the final configuration. The referenced docs are important when more background is needed to adjust the implementation to a specific scenario.
<!-- TOC -->
- GitLab Duo Self-Hosted: Complete AWS/Google Cloud Deployment Guide with Ollama Integration
- [Prerequisites](#prerequisites)
- [Virtual Machines](#virtual-machines)
- [Resources & Operating System](#resources--operating-system)
- [Networking](#networking)
- [GitLab](#gitlab)
- [Licensing](#licensing)
- [SSL/TLS](#ssltls)
- [Introduction](#introduction)
- [Installation](#installation)
- [AI Gateway](#ai-gateway)
- [Ollama](#ollama)
- [Installation](#installation)
- [Model Deployment](#model-deployment)
- [Integration](#integration)
- [Enable GitLab Duo for Root User](#enable-gitlab-duo-for-root-user)
- [Configure Self-Hosted Model in GitLab](#configure-gitlab-duo-self-hosted-in-gitlab)
- [Verification](#verification)
<!-- /TOC -->
## Prerequisites
### Virtual Machines
#### Resources & Operating System
We will install GitLab, GitLab AI Gateway and Ollama each in their own separate virtual machine. While we used Ubuntu 24.0x in this guide, you have flexibility in choosing any Unix-based operating system that meets your organization's requirements and preferences. However, using a Unix-based operating system is mandatory for this setup. This ensures system stability, security, and compatibility with the required software stack. This setup provides a good balance between cost and performance for testing and evaluation phases, though you may need to upgrade the GPU instance type when moving to production, depending on your usage requirements and team size.
| | **GCP** | **AWS** | **OS** | **Disk** |
|----------------|---------------|-------------|-----------|----------|
| **GitLab** | c2-standard-4 | c6xlarge | Ubuntu 24 | 50 GB |
| **AI Gateway** | e2-medium | t2.medium | Ubuntu 24 | 20 GB |
| **Ollama** | n1-standard-4 | g4dn.xlarge | Ubuntu 24 | 50 GB |
For more information about the component and its purpose, see [AI Gateway](../../user/gitlab_duo/gateway.md).
```mermaid
%%{init: { "fontFamily": "GitLab Sans" }}%%
flowchart LR
accTitle: GitLab Duo Self-Hosted architecture
accDescr: Shows the flow from GitLab Ultimate to the AI gateway, which connects to Ollama running Mistral.
A[GitLab<br/>Ultimate] --> C
C[GitLab<br/>AI Gateway] --> B[Ollama<br/>Mistral]
```
These components work together to realize the Self-Hosted AI functionality. This guide provides detailed instructions for building a complete self-hosted AI environment using Ollama as the LLM server.
{{< alert type="note" >}}
While for a full production environment, the [official documentation](../../administration/gitlab_duo_self_hosted/supported_models_and_hardware_requirements.md) recommends more powerful GPU instances such as 1x NVIDIA A100 (40 GB), the g4dn.xlarge instance type should be sufficient for evaluation purposes with a small team of users.
{{< /alert >}}
#### Networking
To enable access to GitLab, a static public IP address (such as an Elastic IP in AWS or an External IP in Google Cloud) is required. All other components can and should use static internal IP addresses for internal communication. We assume all VMs are on the same network and can communicate directly.
| | **Public IP** | **Private IP** |
|----------------|---------------|----------------|
| **GitLab** | yes | yes |
| **AI Gateway** | no | yes |
| **Ollama** | no | yes |
Why Use Internal IPs?
- Internal IPs remain static throughout an instance's lifetime in AWS/Google Cloud.
- Only the GitLab server needs external access, while other components, like Ollama, rely on internal communication.
- This approach reduces costs by avoiding charges for public IP addresses and enhances security by keeping the LLM server inaccessible from the internet.
### GitLab
The rest of this guide assumes you already have an instance of GitLab up and running that meets the following requirements:
#### Licensing
Operating GitLab Duo Self-Hosted requires both a GitLab Ultimate license and a GitLab Duo Enterprise license. The GitLab Ultimate license works with either online or offline licensing options. This documentation assumes that both licenses have been previously obtained and are available for implementation.
#### SSL/TLS
A valid SSL certificate (such as Let's Encrypt) must be configured for the GitLab instance. This is not just a security best practice, but a technical requirement because:
- The AI Gateway system (as of January 2025) strictly requires proper SSL verification when communicating with GitLab
- Self-signed certificates are not accepted by the AI Gateway
- Non-SSL connections (HTTP) are also not supported
GitLab provides a convenient automated SSL setup process:
- During the GitLab installation, simply specify your URL with "https://" prefix
- GitLab will automatically:
- Obtain a Let's Encrypt SSL certificate
- Install the certificate
- Configure HTTPS
- No manual SSL certificate management is required
During the installation of GitLab, the procedure looks something like this:
1. Allocate and associate public and static IP address with the GitLab instance
1. Configure your DNS records to point at that address
1. During GitLab installation, use your HTTPS URL (for example, `https://gitlab.yourdomain.com`)
1. Let GitLab handle the SSL certificate setup automatically
For details, refer to the [documentation](https://docs.gitlab.com/omnibus/settings/ssl/) page.
## Introduction
Before setting up GitLab Duo Self-Hosted, it's important to understand how AI works. AI model is the AI's brain trained with data. This brain needs a framework to operate, which is called an LLM Serving Platform or simply "Serving Platform." In AWS, this is "Amazon Bedrock," in Azure, it's "Azure OpenAI Service," and for ChatGPT, it's their platform. For Anthropic, it's "Claude.". For self-hosing models, Ollama is a common choice.
For example:
- In AWS, the serving platform is Amazon Bedrock.
- In Azure, it's the Azure OpenAI Service.
- For ChatGPT, it's OpenAI's proprietary platform
- For Anthropic, the serving platform is Claude.
When you host an AI model yourself, you'll also need to choose a serving platform. A popular option for self-hosted models is Ollama.
In this analogy, the brain part for ChatGPT is the GPT-4 model, while in the Anthropic ecosystem, it's the Claude 3.7 Sonnet model. The serving platform acts as the vital framework that connects the brain to the world, enabling it to "think" and interact effectively.
For further information about supported serving platforms and models, see [LLM Serving Platforms](../../administration/gitlab_duo_self_hosted/supported_llm_serving_platforms.md) and [Models](../../administration/gitlab_duo_self_hosted/supported_models_and_hardware_requirements.md).
**What is Ollama?**
Ollama is a streamlined, open-source framework for running Large Language Models (LLMs) in local environments. It simplifies the traditionally complex process of deploying AI models, making it accessible to both individuals and organizations looking for efficient, flexible, and scalable AI solutions.
Key Highlights:
1. **Simplified Deployment**: A user-friendly command-line interface ensures quick setup and hassle-free installation.
1. **Wide Model Support**: Compatible with popular open-source models like Llama 2, Mistral, and Code Llama.
1. **Optimized Performance**: Operates seamlessly across both GPU and CPU environments for resource efficiency.
1. **Integration-Ready**: Features an OpenAI-compatible API for easy integration with existing tools and workflows.
1. **No Containers Needed**: Runs directly on host systems, eliminating the need for Docker or containerized environments.
1. **Versatile Hosting Options**: Deployable on local machines, on-premises servers, or cloud GPU instances.
Designed for simplicity and performance, Ollama empowers users to harness the power of LLMs without the complexity of traditional AI infrastructure. Further details on setup and supported models will be covered later in the documentation.
- [Ollama Model Support](https://ollama.com/search)
## Installation
### AI Gateway
While the official installation guide is available in [Install the GitLab AI gateway](../../install/install_ai_gateway.md), here's a streamlined approach for setting up the AI Gateway. As of January
2025, the image `gitlab/model-gateway:self-hosted-v17.6.0-ee` has been verified to work with GitLab 17.7.
1. Ensure that ...
- TCP port 5052 to the API Gateway VM is permitted (check security group configuration)
- You replace `GITLAB_DOMAIN` with the domain name to YOUR instance of GitLab in the following code snippet:
1. Run the following command to start the GitLab AI Gateway:
```shell
GITLAB_DOMAIN="gitlab.yourdomain.com"
docker run -p 5052:5052 \
-e AIGW_GITLAB_URL=$GITLAB_DOMAIN \
-e AIGW_GITLAB_API_URL=https://${GITLAB_DOMAIN}/api/v4/ \
-e AIGW_AUTH__BYPASS_EXTERNAL=true \
gitlab/model-gateway:self-hosted-v17.6.0-ee
```
The following table explains key environment variables and their roles in setting up your instance:
| **Variable** | **Description** |
|------------------------------|-----------------|
| `AIGW_GITLAB_URL` | Your GitLab instance domain. |
| `AIGW_GITLAB_API_URL` | The API endpoint of your GitLab instance. |
| `AIGW_AUTH__BYPASS_EXTERNAL` | Configuration for handling authentication. |
During the initial setup and testing phase, you can set AIGW_AUTH__BYPASS_EXTERNAL=true to bypass authentication and avoid issues. However, this configuration should never be used in a production environment or on servers exposed to the internet.
### Ollama
#### Installation
1. Install Ollama using the official installation script:
```shell
curl --fail --silent --show-error --location "https://ollama.com/install.sh" | sh
```
1. Configure Ollama to listen on the internal IP by adding the `OLLAMA_HOST` environment variable to its startup configuration
```shell
systemctl edit ollama.service
```
```ini
[Service]
Environment="OLLAMA_HOST=172.31.11.27"
```
{{< alert type="note" >}}
Replace the IP address with your actual server's internal IP address.
{{< /alert >}}
1. Reload and restart the service:
```shell
systemctl daemon-reload
systemctl restart ollama
```
#### Model Deployment
1. Set the environment variable:
```shell
export OLLAMA_HOST=172.31.11.27
```
1. Install the Mistral Instruct model:
```shell
ollama pull mistral:instruct
```
The `mistral:instruct` model requires approximately 4.1 GB of storage space and will take a while to download depending on your connection speed.
1. Verify the model installation:
```shell
ollama list
```
The command should show the installed model in the list.
## Integration
### Enable GitLab Duo for Root User
1. Access the GitLab Web Interface
- Log in as the administrator user
- Navigate to the Admin Area (wrench icon)
1. Configure Duo License
- Go to the "Subscription" section in the left sidebar
- You should see "Seats used: 1/5" indicating available Duo seats
- Note: Only one seat is needed for the root user
1. Assign Duo License to Root
- Navigate to "Admin area" > "GitLab Duo" > "Seat utilization"
- Locate the root user (Administrator) in the user list
- Toggle the switch in the "GitLab Duo Enterprise" column to enable Duo for the root user
- The toggle button should turn blue when enabled
{{< alert type="note" >}}
Enabling Duo for just the root user is sufficient for initial setup and testing. Additional users can be granted Duo access later if needed, within your seat license limitations.
{{< /alert >}}
### Configure GitLab Duo Self-Hosted in GitLab
1. Access GitLab Duo Self-Hosted Configuration
- Navigate to Admin Area > GitLab Duo > "Configure GitLab Duo Self-hosted"
- Click "Add self-hosted model" button
1. Configure Model Settings
- **Deployment name**: Choose a descriptive name (for example `Mistral-7B-Instruct-v0.3 on AWS Tokyo`)
- **Model family**: Select "Mistral" from the dropdown list
- **Endpoint**: Enter your Ollama server URL in the format:
```plaintext
http://[Internal-IP]:11434/v1
```
Example: `http://172.31.11.27:11434/v1`
- **Model identifier**: Enter `custom_openai/mistral:instruct`
- **API Key**: Enter any placeholder text (for example, `test`) as this field cannot be left blank
1. Enable AI Features
- Navigate to the "AI-native features" tab
- Assign the configured model to the following features:
- Code Suggestions > Code Generation
- Code Suggestions > Code Completion
- GitLab Duo Chat > General Chat
- Select your deployed model from the dropdown list for each feature
These settings establish the connection between your GitLab instance and the self-hosted Ollama model through the AI Gateway, enabling AI-native features within GitLab.
## Verification
1. Create a test group in GitLab
1. The GitLab Duo Chat icon should appear in the top right corner
1. This indicates successful integration between GitLab and the AI Gateway
|
https://docs.gitlab.com/solutions/servicenow
|
https://gitlab.com/gitlab-org/gitlab/-/tree/master/doc/solutions/servicenow.md
|
2025-08-13
|
doc/solutions/integrations
|
[
"doc",
"solutions",
"integrations"
] |
servicenow.md
|
Create
|
Import
|
To determine the technical writer assigned to the Stage/Group associated with this page, see https://handbook.gitlab.com/handbook/product/ux/technical-writing/#assignments
|
ServiceNow
|
Configure ServiceNow to centralize and automate GitLab workflows.
|
{{< details >}}
- Tier: Free, Premium, Ultimate
- Offering: GitLab.com, GitLab Self-Managed, GitLab Dedicated
{{< /details >}}
ServiceNow offers several integrations to help centralize and automate your
management of GitLab workflows.
To simplify your stack and streamline your processes, you should use GitLab [deployment approvals](../../api/oauth2.md) whenever possible.
## GitLab spoke
With the GitLab spoke in ServiceNow, you can automate actions for GitLab
projects, groups, users, issues, merge requests, branches, and repositories.
For a full list of features, see the
[GitLab spoke documentation (Xanadu Release)](https://docs.servicenow.com/bundle/xanadu-integrate-applications/page/administer/integrationhub-store-spokes/concept/gitlab-spoke.html).
You must [configure GitLab as an OAuth 2.0 authentication service provider](../../integration/oauth_provider.md),
which involves creating an application and then providing the Application ID
and Secret in ServiceNow.
## GitLab SCM and Continuous Integration for DevOps
In ServiceNow DevOps, you can integrate with GitLab repositories and GitLab CI/CD
to centralize your view of GitLab activity and your change management processes.
You can:
- Track information about activity in GitLab repositories and CI/CD pipelines in
ServiceNow.
- Integrate with GitLab CI/CD pipelines, by automating the creation of change
tickets and determining criteria for changes to auto-approve.
For more information, refer to the following ServiceNow resources:
- [ServiceNow DevOps home page](https://www.servicenow.com/products/devops.html)
- [ServiceNow DevOps documentation](https://docs.servicenow.com/bundle/tokyo-devops/page/product/enterprise-dev-ops/concept/dev-ops-bundle-landing-page.html)
- [GitLab SCM and Continuous Integration for DevOps](https://store.servicenow.com/sn_appstore_store.do#!/store/application/54dc4eacdbc2dcd02805320b7c96191e/)
|
---
stage: Create
group: Import
info: To determine the technical writer assigned to the Stage/Group associated with
this page, see https://handbook.gitlab.com/handbook/product/ux/technical-writing/#assignments
title: ServiceNow
description: Configure ServiceNow to centralize and automate GitLab workflows.
breadcrumbs:
- doc
- solutions
- integrations
---
{{< details >}}
- Tier: Free, Premium, Ultimate
- Offering: GitLab.com, GitLab Self-Managed, GitLab Dedicated
{{< /details >}}
ServiceNow offers several integrations to help centralize and automate your
management of GitLab workflows.
To simplify your stack and streamline your processes, you should use GitLab [deployment approvals](../../api/oauth2.md) whenever possible.
## GitLab spoke
With the GitLab spoke in ServiceNow, you can automate actions for GitLab
projects, groups, users, issues, merge requests, branches, and repositories.
For a full list of features, see the
[GitLab spoke documentation (Xanadu Release)](https://docs.servicenow.com/bundle/xanadu-integrate-applications/page/administer/integrationhub-store-spokes/concept/gitlab-spoke.html).
You must [configure GitLab as an OAuth 2.0 authentication service provider](../../integration/oauth_provider.md),
which involves creating an application and then providing the Application ID
and Secret in ServiceNow.
## GitLab SCM and Continuous Integration for DevOps
In ServiceNow DevOps, you can integrate with GitLab repositories and GitLab CI/CD
to centralize your view of GitLab activity and your change management processes.
You can:
- Track information about activity in GitLab repositories and CI/CD pipelines in
ServiceNow.
- Integrate with GitLab CI/CD pipelines, by automating the creation of change
tickets and determining criteria for changes to auto-approve.
For more information, refer to the following ServiceNow resources:
- [ServiceNow DevOps home page](https://www.servicenow.com/products/devops.html)
- [ServiceNow DevOps documentation](https://docs.servicenow.com/bundle/tokyo-devops/page/product/enterprise-dev-ops/concept/dev-ops-bundle-landing-page.html)
- [GitLab SCM and Continuous Integration for DevOps](https://store.servicenow.com/sn_appstore_store.do#!/store/application/54dc4eacdbc2dcd02805320b7c96191e/)
|
https://docs.gitlab.com/solutions/integrations
|
https://gitlab.com/gitlab-org/gitlab/-/tree/master/doc/solutions/_index.md
|
2025-08-13
|
doc/solutions/integrations
|
[
"doc",
"solutions",
"integrations"
] |
_index.md
|
Solutions Architecture
|
Solutions Architecture
|
This page is owned by the Solutions Architecture team.
|
Integrations
| null |
This documentation section covers a variety of Integrations.
## Cloud solutions by provider
[ServiceNow](servicenow.md)
## Self-Hosted Model
[Complete AWS/Google Cloud Deployment Guide with Ollama Integration](aws_googlecloud_ollama.md)
|
---
stage: Solutions Architecture
group: Solutions Architecture
info: This page is owned by the Solutions Architecture team.
title: Integrations
breadcrumbs:
- doc
- solutions
- integrations
---
This documentation section covers a variety of Integrations.
## Cloud solutions by provider
[ServiceNow](servicenow.md)
## Self-Hosted Model
[Complete AWS/Google Cloud Deployment Guide with Ollama Integration](aws_googlecloud_ollama.md)
|
https://docs.gitlab.com/solutions/cloud
|
https://gitlab.com/gitlab-org/gitlab/-/tree/master/doc/solutions/_index.md
|
2025-08-13
|
doc/solutions/cloud
|
[
"doc",
"solutions",
"cloud"
] |
_index.md
|
Solutions Architecture
|
Solutions Architecture
|
This page is owned by the Solutions Architecture team.
|
Cloud solutions
| null |
This documentation section covers a variety of Cloud Solutions.
## Cloud solutions by provider
[AWS Solutions](aws/_index.md)
|
---
stage: Solutions Architecture
group: Solutions Architecture
info: This page is owned by the Solutions Architecture team.
title: Cloud solutions
breadcrumbs:
- doc
- solutions
- cloud
---
This documentation section covers a variety of Cloud Solutions.
## Cloud solutions by provider
[AWS Solutions](aws/_index.md)
|
https://docs.gitlab.com/solutions/cloud/gitaly_sre_for_aws
|
https://gitlab.com/gitlab-org/gitlab/-/tree/master/doc/solutions/cloud/gitaly_sre_for_aws.md
|
2025-08-13
|
doc/solutions/cloud/aws
|
[
"doc",
"solutions",
"cloud",
"aws"
] |
gitaly_sre_for_aws.md
|
Solutions Architecture
|
Solutions Architecture
|
This page is owned by the Solutions Architecture team.
|
SRE Considerations for Gitaly on AWS
|
Doing SRE for Gitaly instances on AWS.
|
{{< details >}}
- Tier: Free, Premium, Ultimate
- Offering: GitLab Self-Managed
{{< /details >}}
## Gitaly SRE considerations
Gitaly is an embedded service for Git Repository Storage. Gitaly and Gitaly Cluster (Praefect) have been engineered by GitLab to overcome fundamental challenges with horizontal scaling of the open source Git binaries that must be used on the service side of GitLab. Here is in-depth technical reading on the topic:
### Why Gitaly was built
If you would like to understand the underlying rationale on why GitLab had to invest in creating Gitaly, read the following minimal list of topics:
- [Git characteristics that make horizontal scaling difficult](https://gitlab.com/gitlab-org/gitaly/-/blob/master/doc/DESIGN.md#git-characteristics-that-make-horizontal-scaling-difficult)
- [Git architectural characteristics and assumptions](https://gitlab.com/gitlab-org/gitaly/-/blob/master/doc/DESIGN.md#git-architectural-characteristics-and-assumptions)
- [Affects on horizontal compute architecture](https://gitlab.com/gitlab-org/gitaly/-/blob/master/doc/DESIGN.md#affects-on-horizontal-compute-architecture)
- [Evidence to back building a new horizontal layer to scale Git](https://gitlab.com/gitlab-org/gitaly/-/blob/master/doc/DESIGN.md#evidence-to-back-building-a-new-horizontal-layer-to-scale-git)
### Gitaly and Praefect elections
As part of Gitaly Cluster (Praefect) consistency, Praefect nodes must occasionally vote on what data copy is the most accurate. This requires an uneven number of Praefect nodes to avoid stalemates. This means that for HA, Gitaly and Praefect require a minimum of three nodes.
### Gitaly performance monitoring
Complete performance metrics should be collected for Gitaly instances for identification of bottlenecks, as they could have to do with disk IO, network IO, or memory.
### Gitaly performance guidelines
Gitaly functions as the primary Git Repository Storage in GitLab. However, it's not a streaming file server. It also does a lot of demanding computing work, such as preparing and caching Git packfiles which informs some of the performance recommendations below.
{{< alert type="note" >}}
All recommendations are for production configurations, including performance testing. For test configurations, like training or functional testing, you can use less expensive options. However, you should adjust or rebuild if performance is an issue.
{{< /alert >}}
#### Overall recommendations
- Production-grade Gitaly must be implemented on instance compute due to all of the previous and following characteristics.
- Never use [burstable instance types](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/burstable-performance-instances.html) (such as `t2`, `t3`, `t4g`) for Gitaly.
- Always use at least the [AWS Nitro generation of instances](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/instance-types.html#ec2-nitro-instances) to ensure many of the below concerns are automatically handled.
- Use Amazon Linux 2 to ensure that all [AWS oriented hardware and OS optimizations](https://aws.amazon.com/amazon-linux-2/faqs/) are maximized without additional configuration or SRE management.
#### CPU and memory recommendations
- The general GitLab Gitaly node recommendations for CPU and Memory assume relatively even loading across repositories. GitLab Performance Tool (GPT) testing of any non-characteristic repositories and/or SRE monitoring of Gitaly metrics may inform when to choose memory and/or CPU higher than general recommendations.
**To accommodate**:
- Git packfile operations are memory and CPU intensive.
- If repository commit traffic is dense, large, or very frequent, then more CPU and Memory are required to handle the load. Patterns such as storing binaries and/or busy or large monorepos are examples that can cause high loading.
#### Disk I/O recommendations
- Use only SSD storage and the [class of Elastic Block Store (EBS) storage](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ebs-volume-types.html) that suites your durability and speed requirements.
- When not using provisioned EBS IO, EBS volume size determines the I/O level, so provisioning volumes that are much larger than needed can be the least expensive way to improve EBS IO.
- If Gitaly performance monitoring shows signs of disk stress then one of the provisioned IOPS levels can be chosen. EBS IOPS levels also have enhanced durability which may be appealing for some implementations aside from performance considerations.
**To accommodate**:
- Gitaly storage is expected to be local (not NFS of any type including EFS).
- Gitaly servers also need disk space for building and caching Git packfiles. This is above and beyond the permanent storage of your Git Repositories.
- Git packfiles are cached in Gitaly. Creation of packfiles in temporary disk benefits from fast disk, and disk caching of packfiles benefits from ample disk space.
#### Network I/O recommendations
- Use only instance types [from the list of ones that support Elastic Network Adapter (ENA) advanced networking](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/instance-types.html#instance-type-summary-table) to ensure that cluster replication latency is not due to instance level network I/O bottlenecks.
- Choose instances with sizes with more than 10 Gbps - but only if needed and only when having proven a node level network bottleneck with monitoring and/or stress testing.
**To accommodate**:
- Gitaly nodes do the main work of streaming repositories for push and pull operations (to add development endpoints, and to CI/CD).
- Gitaly servers need reasonable low latency between cluster nodes and with Praefect services in order for the cluster to maintain operational and data integrity.
- Gitaly nodes should be selected with network bottleneck avoidance as a primary consideration.
- Gitaly nodes should be monitored for network saturation.
- Not all networking issues can be solved through optimizing the node level networking:
- Gitaly Cluster (Praefect) node replication depends on all networking between nodes.
- Gitaly networking performance to pull and push endpoints depends on all networking in between.
### AWS Gitaly backup
Due to the nature of how Praefect tracks the replication metadata of Gitaly disk information, the best backup method is [the official backup and restore Rake tasks](../../../administration/backup_restore/_index.md).
### AWS Gitaly recovery
Gitaly Cluster (Praefect) does not support snapshot backups as these can cause issues where the Praefect database becomes out of syn with the disk storage. Due to the nature of how Praefect rebuilds the replication metadata of Gitaly disk information during a restore, the best recovery method is [the official backup and restore Rake tasks](../../../administration/backup_restore/_index.md).
### Gitaly long term management
Gitaly node disk sizes must be monitored and increased to accommodate Git repository growth and Gitaly temporary and caching storage needs. The storage configuration on all nodes should be kept identical.
|
---
stage: Solutions Architecture
group: Solutions Architecture
info: This page is owned by the Solutions Architecture team.
description: Doing SRE for Gitaly instances on AWS.
title: SRE Considerations for Gitaly on AWS
breadcrumbs:
- doc
- solutions
- cloud
- aws
---
{{< details >}}
- Tier: Free, Premium, Ultimate
- Offering: GitLab Self-Managed
{{< /details >}}
## Gitaly SRE considerations
Gitaly is an embedded service for Git Repository Storage. Gitaly and Gitaly Cluster (Praefect) have been engineered by GitLab to overcome fundamental challenges with horizontal scaling of the open source Git binaries that must be used on the service side of GitLab. Here is in-depth technical reading on the topic:
### Why Gitaly was built
If you would like to understand the underlying rationale on why GitLab had to invest in creating Gitaly, read the following minimal list of topics:
- [Git characteristics that make horizontal scaling difficult](https://gitlab.com/gitlab-org/gitaly/-/blob/master/doc/DESIGN.md#git-characteristics-that-make-horizontal-scaling-difficult)
- [Git architectural characteristics and assumptions](https://gitlab.com/gitlab-org/gitaly/-/blob/master/doc/DESIGN.md#git-architectural-characteristics-and-assumptions)
- [Affects on horizontal compute architecture](https://gitlab.com/gitlab-org/gitaly/-/blob/master/doc/DESIGN.md#affects-on-horizontal-compute-architecture)
- [Evidence to back building a new horizontal layer to scale Git](https://gitlab.com/gitlab-org/gitaly/-/blob/master/doc/DESIGN.md#evidence-to-back-building-a-new-horizontal-layer-to-scale-git)
### Gitaly and Praefect elections
As part of Gitaly Cluster (Praefect) consistency, Praefect nodes must occasionally vote on what data copy is the most accurate. This requires an uneven number of Praefect nodes to avoid stalemates. This means that for HA, Gitaly and Praefect require a minimum of three nodes.
### Gitaly performance monitoring
Complete performance metrics should be collected for Gitaly instances for identification of bottlenecks, as they could have to do with disk IO, network IO, or memory.
### Gitaly performance guidelines
Gitaly functions as the primary Git Repository Storage in GitLab. However, it's not a streaming file server. It also does a lot of demanding computing work, such as preparing and caching Git packfiles which informs some of the performance recommendations below.
{{< alert type="note" >}}
All recommendations are for production configurations, including performance testing. For test configurations, like training or functional testing, you can use less expensive options. However, you should adjust or rebuild if performance is an issue.
{{< /alert >}}
#### Overall recommendations
- Production-grade Gitaly must be implemented on instance compute due to all of the previous and following characteristics.
- Never use [burstable instance types](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/burstable-performance-instances.html) (such as `t2`, `t3`, `t4g`) for Gitaly.
- Always use at least the [AWS Nitro generation of instances](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/instance-types.html#ec2-nitro-instances) to ensure many of the below concerns are automatically handled.
- Use Amazon Linux 2 to ensure that all [AWS oriented hardware and OS optimizations](https://aws.amazon.com/amazon-linux-2/faqs/) are maximized without additional configuration or SRE management.
#### CPU and memory recommendations
- The general GitLab Gitaly node recommendations for CPU and Memory assume relatively even loading across repositories. GitLab Performance Tool (GPT) testing of any non-characteristic repositories and/or SRE monitoring of Gitaly metrics may inform when to choose memory and/or CPU higher than general recommendations.
**To accommodate**:
- Git packfile operations are memory and CPU intensive.
- If repository commit traffic is dense, large, or very frequent, then more CPU and Memory are required to handle the load. Patterns such as storing binaries and/or busy or large monorepos are examples that can cause high loading.
#### Disk I/O recommendations
- Use only SSD storage and the [class of Elastic Block Store (EBS) storage](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ebs-volume-types.html) that suites your durability and speed requirements.
- When not using provisioned EBS IO, EBS volume size determines the I/O level, so provisioning volumes that are much larger than needed can be the least expensive way to improve EBS IO.
- If Gitaly performance monitoring shows signs of disk stress then one of the provisioned IOPS levels can be chosen. EBS IOPS levels also have enhanced durability which may be appealing for some implementations aside from performance considerations.
**To accommodate**:
- Gitaly storage is expected to be local (not NFS of any type including EFS).
- Gitaly servers also need disk space for building and caching Git packfiles. This is above and beyond the permanent storage of your Git Repositories.
- Git packfiles are cached in Gitaly. Creation of packfiles in temporary disk benefits from fast disk, and disk caching of packfiles benefits from ample disk space.
#### Network I/O recommendations
- Use only instance types [from the list of ones that support Elastic Network Adapter (ENA) advanced networking](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/instance-types.html#instance-type-summary-table) to ensure that cluster replication latency is not due to instance level network I/O bottlenecks.
- Choose instances with sizes with more than 10 Gbps - but only if needed and only when having proven a node level network bottleneck with monitoring and/or stress testing.
**To accommodate**:
- Gitaly nodes do the main work of streaming repositories for push and pull operations (to add development endpoints, and to CI/CD).
- Gitaly servers need reasonable low latency between cluster nodes and with Praefect services in order for the cluster to maintain operational and data integrity.
- Gitaly nodes should be selected with network bottleneck avoidance as a primary consideration.
- Gitaly nodes should be monitored for network saturation.
- Not all networking issues can be solved through optimizing the node level networking:
- Gitaly Cluster (Praefect) node replication depends on all networking between nodes.
- Gitaly networking performance to pull and push endpoints depends on all networking in between.
### AWS Gitaly backup
Due to the nature of how Praefect tracks the replication metadata of Gitaly disk information, the best backup method is [the official backup and restore Rake tasks](../../../administration/backup_restore/_index.md).
### AWS Gitaly recovery
Gitaly Cluster (Praefect) does not support snapshot backups as these can cause issues where the Praefect database becomes out of syn with the disk storage. Due to the nature of how Praefect rebuilds the replication metadata of Gitaly disk information during a restore, the best recovery method is [the official backup and restore Rake tasks](../../../administration/backup_restore/_index.md).
### Gitaly long term management
Gitaly node disk sizes must be monitored and increased to accommodate Git repository growth and Gitaly temporary and caching storage needs. The storage configuration on all nodes should be kept identical.
|
https://docs.gitlab.com/solutions/cloud/gitlab_instance_on_aws
|
https://gitlab.com/gitlab-org/gitlab/-/tree/master/doc/solutions/cloud/gitlab_instance_on_aws.md
|
2025-08-13
|
doc/solutions/cloud/aws
|
[
"doc",
"solutions",
"cloud",
"aws"
] |
gitlab_instance_on_aws.md
|
Solutions Architecture
|
Solutions Architecture
|
This page is owned by the Solutions Architecture team.
|
Provision GitLab Instances on AWS
| null |
## Available Infrastructure as Code for GitLab Instance Installation on AWS
The [GitLab Environment Toolkit (GET)](https://gitlab.com/gitlab-org/gitlab-environment-toolkit/-/blob/main/README.md) is a set of opinionated Terraform and Ansible scripts. These scripts help with the deployment of Linux package or Cloud Native Hybrid environments on selected cloud providers and are used by GitLab developers for [GitLab Dedicated](../../../subscriptions/gitlab_dedicated/_index.md) (for example).
You can use the GitLab Environment Toolkit to deploy a Cloud Native Hybrid environment on AWS. However, it's not required and may not support every valid permutation. That said, the scripts are presented as-is and you can adapt them accordingly.
### Two and Three Zone High Availability
While GitLab Reference Architectures generally encourage three zone redundancy, the AWS Well Architected framework consider two zone redundancy as AWS Well Architected. Individual implementations should weigh the costs of two and three zone configurations against their own high availability requirements for a final configuration.
Gitaly Cluster (Praefect) uses a consistency voting system to implement strong consistency between synchronized nodes. Regardless of the number of availability zones implemented, there will always need to be a minimum of three Gitaly and three Praefect nodes in the cluster to avoid voting stalemates cause by an even number of nodes.
## AWS PaaS qualified for all GitLab implementations
For both implementations that used the Linux package or Cloud Native Hybrid implementations, the following GitLab Service roles can be performed by AWS Services (PaaS). Any PaaS solutions that require preconfigured sizing based on the scale of your instance will also be listed in the per-instance size Bill of Materials lists. Those PaaS that do not require specific sizing, are not repeated in the BOM lists (for example, AWS Certification Manager).
These services have been tested with GitLab.
Some services, such as log aggregation, outbound email are not specified by GitLab, but where provided are noted.
| GitLab Services | AWS PaaS (Tested) |
| ------------------------------------------------------------ | ------------------------------ |
| <u>Tested PaaS Mentioned in Reference Architectures</u> | |
| **PostgreSQL Database** | Amazon RDS PostgreSQL |
| **Redis Caching** | Redis ElastiCache |
| **Gitaly Cluster (Git Repository Storage)**<br />(Including Praefect and PostgreSQL) | ASG and Instances |
| **All GitLab storages besides Git Repository Storage**<br />(Includes Git-LFS which is S3 Compatible) | AWS S3 |
| | |
| <u>Tested PaaS for Supplemental Services</u> | |
| **Front End Load Balancing** | AWS ELB |
| **Internal Load Balancing** | AWS ELB |
| **Outbound Email Services** | AWS Simple Email Service (SES) |
| **Certificate Authority and Management** | AWS Certificate Manager (ACM) |
| **DNS** | AWS Route53 (tested) |
| **GitLab and Infrastructure Log Aggregation** | AWS CloudWatch Logs |
| **Infrastructure Performance Metrics** | AWS CloudWatch Metrics |
| | |
| <u>Supplemental Services and Configurations</u> | |
| **Prometheus for GitLab** | AWS EKS (Cloud Native Only) |
| **Grafana for GitLab** | AWS EKS (Cloud Native Only) |
| **Encryption (In Transit / At Rest)** | AWS KMS |
| **Secrets Storage for Provisioning** | AWS Secrets Manager |
| **Configuration Data for Provisioning** | AWS Parameter Store |
| **AutoScaling Kubernetes** | EKS AutoScaling Agent |
|
---
stage: Solutions Architecture
group: Solutions Architecture
info: This page is owned by the Solutions Architecture team.
title: Provision GitLab Instances on AWS
breadcrumbs:
- doc
- solutions
- cloud
- aws
---
## Available Infrastructure as Code for GitLab Instance Installation on AWS
The [GitLab Environment Toolkit (GET)](https://gitlab.com/gitlab-org/gitlab-environment-toolkit/-/blob/main/README.md) is a set of opinionated Terraform and Ansible scripts. These scripts help with the deployment of Linux package or Cloud Native Hybrid environments on selected cloud providers and are used by GitLab developers for [GitLab Dedicated](../../../subscriptions/gitlab_dedicated/_index.md) (for example).
You can use the GitLab Environment Toolkit to deploy a Cloud Native Hybrid environment on AWS. However, it's not required and may not support every valid permutation. That said, the scripts are presented as-is and you can adapt them accordingly.
### Two and Three Zone High Availability
While GitLab Reference Architectures generally encourage three zone redundancy, the AWS Well Architected framework consider two zone redundancy as AWS Well Architected. Individual implementations should weigh the costs of two and three zone configurations against their own high availability requirements for a final configuration.
Gitaly Cluster (Praefect) uses a consistency voting system to implement strong consistency between synchronized nodes. Regardless of the number of availability zones implemented, there will always need to be a minimum of three Gitaly and three Praefect nodes in the cluster to avoid voting stalemates cause by an even number of nodes.
## AWS PaaS qualified for all GitLab implementations
For both implementations that used the Linux package or Cloud Native Hybrid implementations, the following GitLab Service roles can be performed by AWS Services (PaaS). Any PaaS solutions that require preconfigured sizing based on the scale of your instance will also be listed in the per-instance size Bill of Materials lists. Those PaaS that do not require specific sizing, are not repeated in the BOM lists (for example, AWS Certification Manager).
These services have been tested with GitLab.
Some services, such as log aggregation, outbound email are not specified by GitLab, but where provided are noted.
| GitLab Services | AWS PaaS (Tested) |
| ------------------------------------------------------------ | ------------------------------ |
| <u>Tested PaaS Mentioned in Reference Architectures</u> | |
| **PostgreSQL Database** | Amazon RDS PostgreSQL |
| **Redis Caching** | Redis ElastiCache |
| **Gitaly Cluster (Git Repository Storage)**<br />(Including Praefect and PostgreSQL) | ASG and Instances |
| **All GitLab storages besides Git Repository Storage**<br />(Includes Git-LFS which is S3 Compatible) | AWS S3 |
| | |
| <u>Tested PaaS for Supplemental Services</u> | |
| **Front End Load Balancing** | AWS ELB |
| **Internal Load Balancing** | AWS ELB |
| **Outbound Email Services** | AWS Simple Email Service (SES) |
| **Certificate Authority and Management** | AWS Certificate Manager (ACM) |
| **DNS** | AWS Route53 (tested) |
| **GitLab and Infrastructure Log Aggregation** | AWS CloudWatch Logs |
| **Infrastructure Performance Metrics** | AWS CloudWatch Metrics |
| | |
| <u>Supplemental Services and Configurations</u> | |
| **Prometheus for GitLab** | AWS EKS (Cloud Native Only) |
| **Grafana for GitLab** | AWS EKS (Cloud Native Only) |
| **Encryption (In Transit / At Rest)** | AWS KMS |
| **Secrets Storage for Provisioning** | AWS Secrets Manager |
| **Configuration Data for Provisioning** | AWS Parameter Store |
| **AutoScaling Kubernetes** | EKS AutoScaling Agent |
|
https://docs.gitlab.com/solutions/cloud/aws
|
https://gitlab.com/gitlab-org/gitlab/-/tree/master/doc/solutions/cloud/_index.md
|
2025-08-13
|
doc/solutions/cloud/aws
|
[
"doc",
"solutions",
"cloud",
"aws"
] |
_index.md
|
Solutions Architecture
|
Solutions Architecture
|
This page is owned by the Solutions Architecture team.
|
AWS Solutions
| null |
This documentation covers solutions relating to leveraging GitLab with and on Amazon Web Services (AWS).
- [GitLab partnership certifications and designations from AWS](gitlab_aws_partner_designations.md)
- [GitLab AWS Integration Index](gitlab_aws_integration.md)
- [GitLab Instances on AWS EKS](gitlab_instance_on_aws.md)
- [SRE Considerations for Gitaly on AWS](gitaly_sre_for_aws.md)
- [Provision GitLab on a single EC2 instance in AWS](gitlab_single_box_on_aws.md)
## Cloud platform well architected compliance
Testing-backed architectural qualification is a fundamental concept behind Cloud solution implementations:
- Cloud solution implementations maintain GitLab Reference Architecture compliance and provide [GitLab Performance Tool](https://gitlab.com/gitlab-org/quality/performance) (GPT) reports to demonstrate adherence to them.
- Cloud solution implementations may be qualified by and/or contributed to by the technology vendor. For instance, an implementation pattern for AWS may be officially reviewed by AWS.
- Cloud solution implementations may specify and test Cloud Platform PaaS services for suitability for GitLab. This testing can be coordinated and help qualify these technologies for Reference Architectures. For instance, qualifying compatibility with and availability of runtime versions of top level PaaS such as those for PostgreSQL and Redis.
- Cloud solution implementations can provided qualified testing for platform limitations, for example, ensuring Gitaly Cluster (Praefect) can work correctly on specific Cloud Platform availability zone latency and throughput characteristics or qualifying what levels of available platform partner local disk performance is workable for Gitaly server to operate with integrity.
## AWS known issues list
Known issues are gathered from within GitLab and from customer reported issues. Customers successfully implement GitLab with a variety of "as a Service" components that GitLab has not specifically been designed for, nor has ongoing testing for. While GitLab does take partner technologies very seriously, the highlighting of known issues here is a convenience for implementers and it does not imply that GitLab has targeted compatibility with, nor carries any type of guarantee of running on the partner technology where the issues occur. Consult individual issues to understand the GitLab stance and plans on any given known issue.
See the [GitLab AWS known issues list](https://gitlab.com/gitlab-com/alliances/aws/public-tracker/-/issues?label_name[]=AWS+Known+Issue) for a complete list.
## Patterns with working code examples for using GitLab with AWS
[The Guided Explorations' subgroup for AWS](https://gitlab.com/guided-explorations/aws) contains a variety of working example projects.
## Platform partner specificity
Cloud solution implementations enable platform-specific terminology, best practice architecture, and platform-specific build manifests:
- Cloud solution implementations are more vendor specific. For instance, advising specific compute instances / VMs / nodes instead of vCPUs or other generalized measures.
- Cloud solution implementations are oriented to implementing good architecture for the vendor in view.
- Cloud solution implementations are written to an audience who is familiar with building on the infrastructure that the implementation pattern targets. For example, if the implementation pattern is for GCP, the specific terminology of GCP is used - including using the specific names for PaaS services.
- Cloud solution implementations can test and qualify if the versions of PaaS available are compatible with GitLab (for example, PostgreSQL, Redis, etc.).
## AWS Platform as a Service (PaaS) specification and usage
Platform as a Service options are a huge portion of the value provided by Cloud Platforms as they simplify operational complexity and reduce the SRE and security skilling required to operate advanced, highly available technology services. Cloud solution implementations can be pre-qualified against the partner PaaS options.
- Cloud solution implementations help implementers understand what PaaS options are known to work and how to choose between PaaS solutions when a single platform has more than one PaaS option for the same GitLab role.
- For instance, where reference architectures do not have a specific recommendation on what technology is leveraged for GitLab outbound email services or what the sizing should be - a Reference Implementation may advise using a cloud providers Email as a Service (PaaS) and possibly even with specific settings.
You can read more at [AWS services are usable to deploy GitLab infrastructure](gitlab_instance_on_aws.md).
## Cost optimizing engineering
Cost engineering is a fundamental aspect of Cloud Architecture and frequently the savings capabilities available on a platform exert strong influence on how to build out scaled computing.
- Cloud solution implementations may engineer specifically for the savings models available on a platform provider. An AWS example would be maximizing the occurrence of a specific instance type for taking advantage of reserved instances.
- Cloud solution implementations may leverage ephemeral compute where appropriate and with appropriate customer guidelines. For instance, a Kubernetes node group dedicated to runners on ephemeral compute (with appropriate GitLab Runner tagging to indicate the compute type).
- Cloud solution implementations may include vendor specific cost calculators.
## Actionability and automatability orientation
Cloud solution implementations are one step closer to specifics that can be used as a source for build instructions and automation code:
- Cloud solution implementations enable builders to generate a list of vendor specific resources required to implement GitLab for a given Reference Architecture.
- Cloud solution implementations enable builders to use manual instructions or to create automation to build out the reference implementation.
## Intended audiences and contributors
The primary audiences for and contributors to this information is the GitLab **Implementation Eco System** which consists of at least:
GitLab Implementation Community:
- Customers
- GitLab Channel Partners (Integrators)
- Platform Partners
GitLab Internal Implementation Teams:
- Quality / Distribution / Self-Managed
- Alliances
- Training
- Support
- Professional Services
- Public Sector
|
---
stage: Solutions Architecture
group: Solutions Architecture
info: This page is owned by the Solutions Architecture team.
title: AWS Solutions
breadcrumbs:
- doc
- solutions
- cloud
- aws
---
This documentation covers solutions relating to leveraging GitLab with and on Amazon Web Services (AWS).
- [GitLab partnership certifications and designations from AWS](gitlab_aws_partner_designations.md)
- [GitLab AWS Integration Index](gitlab_aws_integration.md)
- [GitLab Instances on AWS EKS](gitlab_instance_on_aws.md)
- [SRE Considerations for Gitaly on AWS](gitaly_sre_for_aws.md)
- [Provision GitLab on a single EC2 instance in AWS](gitlab_single_box_on_aws.md)
## Cloud platform well architected compliance
Testing-backed architectural qualification is a fundamental concept behind Cloud solution implementations:
- Cloud solution implementations maintain GitLab Reference Architecture compliance and provide [GitLab Performance Tool](https://gitlab.com/gitlab-org/quality/performance) (GPT) reports to demonstrate adherence to them.
- Cloud solution implementations may be qualified by and/or contributed to by the technology vendor. For instance, an implementation pattern for AWS may be officially reviewed by AWS.
- Cloud solution implementations may specify and test Cloud Platform PaaS services for suitability for GitLab. This testing can be coordinated and help qualify these technologies for Reference Architectures. For instance, qualifying compatibility with and availability of runtime versions of top level PaaS such as those for PostgreSQL and Redis.
- Cloud solution implementations can provided qualified testing for platform limitations, for example, ensuring Gitaly Cluster (Praefect) can work correctly on specific Cloud Platform availability zone latency and throughput characteristics or qualifying what levels of available platform partner local disk performance is workable for Gitaly server to operate with integrity.
## AWS known issues list
Known issues are gathered from within GitLab and from customer reported issues. Customers successfully implement GitLab with a variety of "as a Service" components that GitLab has not specifically been designed for, nor has ongoing testing for. While GitLab does take partner technologies very seriously, the highlighting of known issues here is a convenience for implementers and it does not imply that GitLab has targeted compatibility with, nor carries any type of guarantee of running on the partner technology where the issues occur. Consult individual issues to understand the GitLab stance and plans on any given known issue.
See the [GitLab AWS known issues list](https://gitlab.com/gitlab-com/alliances/aws/public-tracker/-/issues?label_name[]=AWS+Known+Issue) for a complete list.
## Patterns with working code examples for using GitLab with AWS
[The Guided Explorations' subgroup for AWS](https://gitlab.com/guided-explorations/aws) contains a variety of working example projects.
## Platform partner specificity
Cloud solution implementations enable platform-specific terminology, best practice architecture, and platform-specific build manifests:
- Cloud solution implementations are more vendor specific. For instance, advising specific compute instances / VMs / nodes instead of vCPUs or other generalized measures.
- Cloud solution implementations are oriented to implementing good architecture for the vendor in view.
- Cloud solution implementations are written to an audience who is familiar with building on the infrastructure that the implementation pattern targets. For example, if the implementation pattern is for GCP, the specific terminology of GCP is used - including using the specific names for PaaS services.
- Cloud solution implementations can test and qualify if the versions of PaaS available are compatible with GitLab (for example, PostgreSQL, Redis, etc.).
## AWS Platform as a Service (PaaS) specification and usage
Platform as a Service options are a huge portion of the value provided by Cloud Platforms as they simplify operational complexity and reduce the SRE and security skilling required to operate advanced, highly available technology services. Cloud solution implementations can be pre-qualified against the partner PaaS options.
- Cloud solution implementations help implementers understand what PaaS options are known to work and how to choose between PaaS solutions when a single platform has more than one PaaS option for the same GitLab role.
- For instance, where reference architectures do not have a specific recommendation on what technology is leveraged for GitLab outbound email services or what the sizing should be - a Reference Implementation may advise using a cloud providers Email as a Service (PaaS) and possibly even with specific settings.
You can read more at [AWS services are usable to deploy GitLab infrastructure](gitlab_instance_on_aws.md).
## Cost optimizing engineering
Cost engineering is a fundamental aspect of Cloud Architecture and frequently the savings capabilities available on a platform exert strong influence on how to build out scaled computing.
- Cloud solution implementations may engineer specifically for the savings models available on a platform provider. An AWS example would be maximizing the occurrence of a specific instance type for taking advantage of reserved instances.
- Cloud solution implementations may leverage ephemeral compute where appropriate and with appropriate customer guidelines. For instance, a Kubernetes node group dedicated to runners on ephemeral compute (with appropriate GitLab Runner tagging to indicate the compute type).
- Cloud solution implementations may include vendor specific cost calculators.
## Actionability and automatability orientation
Cloud solution implementations are one step closer to specifics that can be used as a source for build instructions and automation code:
- Cloud solution implementations enable builders to generate a list of vendor specific resources required to implement GitLab for a given Reference Architecture.
- Cloud solution implementations enable builders to use manual instructions or to create automation to build out the reference implementation.
## Intended audiences and contributors
The primary audiences for and contributors to this information is the GitLab **Implementation Eco System** which consists of at least:
GitLab Implementation Community:
- Customers
- GitLab Channel Partners (Integrators)
- Platform Partners
GitLab Internal Implementation Teams:
- Quality / Distribution / Self-Managed
- Alliances
- Training
- Support
- Professional Services
- Public Sector
|
https://docs.gitlab.com/solutions/cloud/gitlab_aws_integration
|
https://gitlab.com/gitlab-org/gitlab/-/tree/master/doc/solutions/cloud/gitlab_aws_integration.md
|
2025-08-13
|
doc/solutions/cloud/aws
|
[
"doc",
"solutions",
"cloud",
"aws"
] |
gitlab_aws_integration.md
|
Solutions Architecture
|
Solutions Architecture
|
This page is owned by the Solutions Architecture team.
|
Integrate with AWS
|
Integrations Solutions Index for GitLab and AWS.
|
Learn how to integrate GitLab and AWS.
This content is intended for GitLab team members as well as members of the wider community.
Unless otherwise noted, all of this content applies to both GitLab.com and GitLab Self-Managed instances.
This page attempts to index the ways in which GitLab can integrate with AWS. It does so whether the integration is the result of configuring general functionality, was built in to AWS or GitLab or is provided as a solution.
| Text Tag | Configuration / Built / Solution | Support/Maintenance |
| ------------------------ | ------------------------------------------------------------ | ------------------------------------------------------------ |
| `[AWS Configuration]` | Integration via Configuring Existing AWS Functionality | AWS |
| `[GitLab Configuration]` | Integration via Configuring Existing GitLab Functionality | GitLab |
| `[AWS Built]` | Built into AWS by Product Team to Address AWS Integration | AWS |
| `[GitLab Built]` | Built into GitLab by Product Team to Address AWS Integration | GitLab |
| `[AWS Solution]` | Built as Solution Example by AWS or AWS Partners | Community/Example |
| `[GitLab Solution]` | Built as Solution Example by GitLab or GitLab Partners | Community/Example |
| `[CI Solution]` | Built, at least in part, using GitLab CI and therefore <br />more customer customizable. | Items tagged `[CI Solution]` will <br />also carry one of the other tags <br />that indicate the maintenance status. |
## Integrations For Development Activities
These integrations have to do with using GitLab to build application workloads and deploy them to AWS.
### SCM Integrations
#### AWS CodeStar Connection Integrations
[8/14/2023 AWS Release Announcement for GitLab.com SaaS](https://aws.amazon.com/about-aws/whats-new/2023/08/aws-codepipeline-supports-gitlab/)
[12/28/2023 AWS Release Announcement for Self-Managed / Dedicated](https://aws.amazon.com/about-aws/whats-new/2023/12/codepipeline-gitlab-self-managed/)
**AWS CodeStar Connections** - enables SCM connections to multiple AWS Services.
[Configure GitLab](https://docs.aws.amazon.com/dtconsole/latest/userguide/connections-create-gitlab.html).
[Supported Providers](https://docs.aws.amazon.com/dtconsole/latest/userguide/supported-versions-connections.html).
[Supported AWS Services](https://docs.aws.amazon.com/dtconsole/latest/userguide/integrations-connections.html) -
each one may have to make updates to support GitLab, so here is the subset that
support GitLab. This works with GitLab.com SaaS, GitLab Self-Managed and GitLab Dedicated.
AWS CodeStar connections are not available in all AWS regions - the exclusion list is
[documented here](https://docs.aws.amazon.com/codepipeline/latest/userguide/action-reference-CodestarConnectionSource.html).
([12/28/2023](https://aws.amazon.com/about-aws/whats-new/2023/12/codepipeline-gitlab-self-managed/)) `[AWS Built]`
[Video Explanation of AWS CodeStar Connection Integration for AWS (1 min)](https://youtu.be/f7qTSa_bNig)
AWS Services that are supported directly by a CodeStar Connection in an AWS account:
- **AWS Service Catalog** directly inherits CodeStar Connections, there is not any specific documentation about GitLab because it just uses any GitLab CodeStar Connection that has been created in the account. ([12/28/2023](https://aws.amazon.com/about-aws/whats-new/2023/12/codepipeline-gitlab-self-managed/)) `[AWS Built]`
- **AWS Proton** directly inherits CodeStar Connections, there is not any specific documentation about GitLab because it just uses any GitLab CodeStar Connection that has been created in the account. ([12/28/2023](https://aws.amazon.com/about-aws/whats-new/2023/12/codepipeline-gitlab-self-managed/)) `[AWS Built]`
- **AWS CodeBuild** - [for GitLab.com, self-managed and dedicated - click documentation tabs here](https://docs.aws.amazon.com/codebuild/latest/userguide/create-project-console.html#create-project-console-source). ([03/26/2024](https://aws.amazon.com/about-aws/whats-new/2024/03/aws-codebuild-gitlab-gitlab-self-managed/)) `[AWS Built]`
Documentation and References:
- [Creating a GitLab CodeStar Connection to a GitLab.com Project](https://docs.aws.amazon.com/codepipeline/latest/userguide/connections-gitlab-managed.html)
- [Creating a AWS CodeStar Connection for GitLab Self-Managed or GitLab Dedicated](https://docs.aws.amazon.com/codepipeline/latest/userguide/connections-gitlab-managed.html) (must allow Internet Ingress from AWS or use a VPC connection)
#### AWS CodePipeline Integrations
[AWS CodePipeline Integration](https://docs.aws.amazon.com/codepipeline/latest/userguide/connections-gitlab.html) - by using GitLab as CodeStar Connections source for CodePipeline, additional AWS service integrations are available. ([12/28/2023](https://aws.amazon.com/about-aws/whats-new/2023/12/codepipeline-gitlab-self-managed/)) `[AWS Built]`
AWS Services that are supported by an AWS CodePipeline integration:
- **Amazon SageMaker MLOps Projects** are created via CodePipeline ([as noted here](https://docs.aws.amazon.com/sagemaker/latest/dg/sagemaker-projects-walkthrough-3rdgit.html#sagemaker-proejcts-walkthrough-connect-3rdgit)), there is not any specific documentation about GitLab because it just uses any GitLab CodeStar Connection that has been created in the account. ([12/28/2023](https://aws.amazon.com/about-aws/whats-new/2023/12/codepipeline-gitlab-self-managed/)) `[AWS Built]`
Documentation and References:
- [Creating a GitLab CodePipeline Integration to a GitLab.com Project](https://docs.aws.amazon.com/codepipeline/latest/userguide/connections-gitlab-managed.html)
- [Creating a AWS CodePipeline Integration for GitLab Self-Managed or GitLab Dedicated](https://docs.aws.amazon.com/codepipeline/latest/userguide/connections-gitlab-managed.html) (must allow Internet Ingress from AWS or use a VPC connection)
#### CodeStar Connections enabled AWS services that are not yet supported for GitLab
- **AWS CloudFormation** publishing of public extensions - not yet supported. `[AWS Built]`
- **Amazon CodeGuru Reviewer Repositories** - not yet supported. `[AWS Built]`
- **AWS App Runner** - not yet supported. `[AWS Built]`
#### Custom GitLab Integration in AWS Services
- **Amazon SageMaker Notebooks** [allow Git repositories to be specified by the Git clone URL](https://docs.aws.amazon.com/sagemaker/latest/dg/nbi-git-resource.html) and configuration of a secret - so GitLab is configurable. ([12/28/2023](https://aws.amazon.com/about-aws/whats-new/2023/12/codepipeline-gitlab-self-managed/)) `[AWS Configuration]`
- **AWS Amplify** - [uses a Git integration mechanism designed by the AWS Amplify team](https://docs.aws.amazon.com/amplify/latest/userguide/getting-started.html). `[AWS Built]`
- **AWS Glue Notebook Jobs** support for GitLab repository URL with personal access token (PAT) authentication at the "job" level. ([10/03/2022](https://aws.amazon.com/about-aws/whats-new/2022/10/aws-glue-git-integration/)) [AWS Docs about configuring GitLab](https://docs.aws.amazon.com/glue/latest/dg/edit-job-add-source-control-integration.html) `[AWS Configuration]`
#### Other SCM Integration Options
- [GitLab Push Mirroring to CodeCommit](../../../user/project/repository/mirror/push.md#set-up-a-push-mirror-from-gitlab-to-aws-codecommit) Workaround enables GitLab repositories to leverage CodePipeline SCM Triggers. GitLab can already leverage S3 and Container Triggers for CodePipeline. This work around enabled CodePipeline capabilities since it was documented. (06/06/2020) `[GitLab Configuration]`
See [CD and Operations Integrations](#cd-and-operations-integrations) below for Continuous Deployment (CD) specific integrations that are also available.
### CI Integrations
- **Direct CI Integrations That Use Keys, IAM or OIDC/JWT to Authenticate to AWS Services from GitLab Runners**
- **Amazon CodeGuru Reviewer CI workflows using GitLab CI** - can be done, not yet documented.`[AWS Solution]` `[CI Solution]`
- [Amazon CodeGuru Secure Scanning using GitLab CI](https://docs.aws.amazon.com/codeguru/latest/security-ug/get-started-gitlab.html) ([06/13/2022](https://aws.amazon.com/about-aws/whats-new/2023/06/amazon-codeguru-security-available-preview/)) `[AWS Solution]` `[CI Solution]`
### CD and Operations Integrations
- **AWS CodeDeploy Integration** - through CodePipeline support discussed previously in the SCM integrations. This capability allows GitLab to interface with [this list of advanced deployment subsystems in AWS](https://docs.aws.amazon.com/codepipeline/latest/userguide/integrations-action-type.html#integrations-deploy). ([12/28/2023](https://aws.amazon.com/about-aws/whats-new/2023/12/codepipeline-gitlab-self-managed/)) `[AWS Built]`
- **AWS SAM Pipelines** - [pipelines support for GitLab](https://aws.amazon.com/about-aws/whats-new/2021/07/simplify-ci-cd-configuration-serverless-applications-your-favorite-ci-cd-system-public-preview/). (7/31/2021)
- [Integrate EKS clusters for application deployment](../../../user/infrastructure/clusters/connect/new_eks_cluster.md). `[GitLab Built]`
- [GitLab pushing a build Artifact to a CodePipeline monitored S3 location](https://docs.aws.amazon.com/codepipeline/latest/userguide/pipelines-about-starting.html#change-detection-methods) `[AWS Built]`
- [GitLab Pushing a container to a CodePipeline monitored AWS ECR](https://docs.aws.amazon.com/codepipeline/latest/userguide/pipelines-about-starting.html#change-detection-methods) `[AWS Built]`
- [Use GitLab.com's Container Registry as an Upstream Registry for AWS ECR via Pull-Through Cache Rules](https://docs.aws.amazon.com/AmazonECR/latest/userguide/pull-through-cache-creating-rule.html) [Configuration Tutorial](tutorials/aws_ecr_pull_through_cache.md) `[AWS Built]`
## End-to-End Solutions for development and deployment of specific development frameworks or ecosystems
Generally solutions demonstrate end-to-end capabilities for the development framework - leveraging all relevant integration techniques to show the art of maximum value for using GitLab and AWS together.
### Serverless
- [Enterprise DevOps Blueprint: Serverless Framework Apps on AWS](https://gitlab.com/guided-explorations/aws/serverless/serverless-framework-aws) - working example code and tutorials. `[GitLab Solution]` `[CI Solution]`
- [Tutorial: Serverless Framework Deployment to AWS with GitLab Serverless SAST Scanning](https://gitlab.com/guided-explorations/aws/serverless/serverless-framework-aws/-/blob/master/TUTORIAL.md) `[GitLab Solution]` `[CI Solution]`
- [Tutorial: Secure Serverless Framework Development with GitLab Security Policy Approval Rules and Managed DevOps Environments](https://gitlab.com/guided-explorations/aws/serverless/serverless-framework-aws/-/blob/prod/TUTORIAL2-SecurityAndManagedEnvs.md?ref_type=heads) `[GitLab Solution]` `[CI Solution]`
### Terraform
- [Enterprise DevOps Blueprint: Terraform Deployment to AWS](https://gitlab.com/guided-explorations/aws/terraform/terraform-web-server-cluster)
- [Tutorial: Terraform Deployment to AWS with GitLab IaC SAST Scanning](https://gitlab.com/guided-explorations/aws/terraform/terraform-web-server-cluster/-/blob/prod/TUTORIAL.md) `[GitLab Solution]` `[CI Solution]`
- [Terraform Deployment to AWS with GitLab Security Policy Approval Rules and Managed DevOps Environments](https://gitlab.com/guided-explorations/aws/terraform/terraform-web-server-cluster/-/blob/prod/TUTORIAL2-SecurityAndManagedEnvs.md) `[GitLab Solution]` `[CI Solution]`
### CloudFormation
[CloudFormation Development and Deployment With GitLab Lifecycle Managed DevOps Environments Working Code](https://gitlab.com/guided-explorations/aws/cloudformation-deploy) `[GitLab Solution]` `[CI Solution]`
### CDK
- [Building Cross-Account Deployment in GitLab Pipelines Using AWS CDK](https://aws.amazon.com/blogs/apn/building-cross-account-deployment-in-gitlab-pipelines-using-aws-cdk/) `[AWS Solution]` `[CI Solution]`
### .NET on AWS
- [Working Example Code for Scaling .NET Framework 4.x Runners on AWS](https://gitlab.com/guided-explorations/aws/dotnet-aws-toolkit) `[GitLab Solution]` `[CI Solution]`
- [Video Walkthrough of Code and Building a .NET Framework 4.x Project](https://www.youtube.com/watch?v=_4r79ZLmDuo) `[GitLab Solution]` `[CI Solution]`
## System to system integration of GitLab and AWS
AWS Identity providers (IDP) can be configured to authenticate into GitLab or GitLab can function as an IDP into AWS accounts.
Top-level groups on GitLab.com are also known as "Namespaces" and naming one after your company is the first step to setting up a tenant for your organization on GitLab.com. Namespaces can be configured for special functionality like SSO which then integrates your IDP into GitLab.
### User authentication and authorization between GitLab and AWS
- [SAML SSO for GitLab.com groups](../../../user/group/saml_sso/_index.md) `[GitLab Configuration]` - GitLab.com only
- [Integrate LDAP with GitLab](../../../administration/auth/ldap/_index.md) `[GitLab Configuration]` - GitLab Self-Managed only
### Runner workload authentication and authorization integration
- [Runner Job Authentication using Open ID & JWT Authentication](../../../ci/cloud_services/aws/_index.md). `[GitLab Built]`
- [Configure OpenID Connect between GitLab and AWS](https://gitlab.com/guided-explorations/aws/configure-openid-connect-in-aws) `[GitLab Solution]` `[CI Solution]`
- [OIDC and Multi-Account Deployment with GitLab and ECS](https://gitlab.com/guided-explorations/aws/oidc-and-multi-account-deployment-with-ecs) `[GitLab Solution]` `[CI Solution]`
## GitLab infrastructure workloads deployed on AWS
While GitLab can be deployed on a single box for up to 500 users, when it is horizontally scaled for very large user counts like 50,000 it expands into being a complex, many tiered platform that benefits from deployment to AWS. GitLab is supports and is regularly tested being backed by AWS services. GitLab is deployable to Ec2 for traditional scaling and to AWS EKS in a Cloud Native Hybrid implementation. It is called Hybrid because specific service layers cannot be placed in a container cluster due to the workload shapes that are common to Git (and common to how Git processes behave handles that workload variety).
### GitLab Instance Compute & Operations Integration
- Installing GitLab Self-Managed on AWS
- [AWS Services that can be used when deploying GitLab](gitlab_instance_on_aws.md)
- GitLab Single EC2 Instance. `[GitLab Built]`
- [Using 5 Seat AWS marketplace subscription](gitlab_single_box_on_aws.md#marketplace-subscription)
- [Using Prepared AMIs](gitlab_single_box_on_aws.md#official-gitlab-releases-as-amis) - Bring Your Own License for Enterprise Edition.
- GitLab Cloud Native Hybrid Scaled on AWS EKS and Paas. `[GitLab Built]`
- [Using GitLab Environment Toolkit (GET)](https://gitlab.com/gitlab-org/gitlab-environment-toolkit) - `[GitLab Solution]`
- GitLab Instance Scaled on AWS EC2 and PaaS. `[GitLab Built]`
- [Using GitLab Environment Toolkit (GET)](https://gitlab.com/gitlab-org/gitlab-environment-toolkit) - `[GitLab Solution]`
- [Amazon Managed Grafana](https://docs.aws.amazon.com/grafana/latest/userguide/gitlab-AMG-datasource.html) for GitLab Self-Managed Prometheus metrics. `[AWS Built]`
### GitLab Runner on AWS Compute
- [GitLab Runner Autoscaler](https://docs.gitlab.com/runner/runner_autoscale/) - core technology built by GitLab Runner team. `[GitLab Built]`
- [GitLab Runner Infrastructure Toolkit (GRIT)](https://gitlab.com/gitlab-org/ci-cd/runner-tools/grit) - managed infrastructure as code stewarded by the GitLab Runner team. Needed to deploy things like the GitLab Runner Autoscaler. `[GitLab Built]`
- [Autoscaling GitLab Runner on AWS EC2](https://docs.gitlab.com/runner/configuration/runner_autoscale_aws/). `[GitLab Built]`
- [GitLab HA Scaling Runner Vending Machine for AWS EC2 ASG](https://gitlab.com/guided-explorations/aws/gitlab-runner-autoscaling-aws-asg/). `[GitLab Solution]`
- Runner vending machine training resources.
- [GitLab EKS Fargate Runners](https://gitlab.com/guided-explorations/aws/eks-runner-configs/gitlab-runner-eks-fargate/-/blob/main/README.md). `[GitLab Solution]`
|
---
stage: Solutions Architecture
group: Solutions Architecture
info: This page is owned by the Solutions Architecture team.
description: Integrations Solutions Index for GitLab and AWS.
title: Integrate with AWS
breadcrumbs:
- doc
- solutions
- cloud
- aws
---
Learn how to integrate GitLab and AWS.
This content is intended for GitLab team members as well as members of the wider community.
Unless otherwise noted, all of this content applies to both GitLab.com and GitLab Self-Managed instances.
This page attempts to index the ways in which GitLab can integrate with AWS. It does so whether the integration is the result of configuring general functionality, was built in to AWS or GitLab or is provided as a solution.
| Text Tag | Configuration / Built / Solution | Support/Maintenance |
| ------------------------ | ------------------------------------------------------------ | ------------------------------------------------------------ |
| `[AWS Configuration]` | Integration via Configuring Existing AWS Functionality | AWS |
| `[GitLab Configuration]` | Integration via Configuring Existing GitLab Functionality | GitLab |
| `[AWS Built]` | Built into AWS by Product Team to Address AWS Integration | AWS |
| `[GitLab Built]` | Built into GitLab by Product Team to Address AWS Integration | GitLab |
| `[AWS Solution]` | Built as Solution Example by AWS or AWS Partners | Community/Example |
| `[GitLab Solution]` | Built as Solution Example by GitLab or GitLab Partners | Community/Example |
| `[CI Solution]` | Built, at least in part, using GitLab CI and therefore <br />more customer customizable. | Items tagged `[CI Solution]` will <br />also carry one of the other tags <br />that indicate the maintenance status. |
## Integrations For Development Activities
These integrations have to do with using GitLab to build application workloads and deploy them to AWS.
### SCM Integrations
#### AWS CodeStar Connection Integrations
[8/14/2023 AWS Release Announcement for GitLab.com SaaS](https://aws.amazon.com/about-aws/whats-new/2023/08/aws-codepipeline-supports-gitlab/)
[12/28/2023 AWS Release Announcement for Self-Managed / Dedicated](https://aws.amazon.com/about-aws/whats-new/2023/12/codepipeline-gitlab-self-managed/)
**AWS CodeStar Connections** - enables SCM connections to multiple AWS Services.
[Configure GitLab](https://docs.aws.amazon.com/dtconsole/latest/userguide/connections-create-gitlab.html).
[Supported Providers](https://docs.aws.amazon.com/dtconsole/latest/userguide/supported-versions-connections.html).
[Supported AWS Services](https://docs.aws.amazon.com/dtconsole/latest/userguide/integrations-connections.html) -
each one may have to make updates to support GitLab, so here is the subset that
support GitLab. This works with GitLab.com SaaS, GitLab Self-Managed and GitLab Dedicated.
AWS CodeStar connections are not available in all AWS regions - the exclusion list is
[documented here](https://docs.aws.amazon.com/codepipeline/latest/userguide/action-reference-CodestarConnectionSource.html).
([12/28/2023](https://aws.amazon.com/about-aws/whats-new/2023/12/codepipeline-gitlab-self-managed/)) `[AWS Built]`
[Video Explanation of AWS CodeStar Connection Integration for AWS (1 min)](https://youtu.be/f7qTSa_bNig)
AWS Services that are supported directly by a CodeStar Connection in an AWS account:
- **AWS Service Catalog** directly inherits CodeStar Connections, there is not any specific documentation about GitLab because it just uses any GitLab CodeStar Connection that has been created in the account. ([12/28/2023](https://aws.amazon.com/about-aws/whats-new/2023/12/codepipeline-gitlab-self-managed/)) `[AWS Built]`
- **AWS Proton** directly inherits CodeStar Connections, there is not any specific documentation about GitLab because it just uses any GitLab CodeStar Connection that has been created in the account. ([12/28/2023](https://aws.amazon.com/about-aws/whats-new/2023/12/codepipeline-gitlab-self-managed/)) `[AWS Built]`
- **AWS CodeBuild** - [for GitLab.com, self-managed and dedicated - click documentation tabs here](https://docs.aws.amazon.com/codebuild/latest/userguide/create-project-console.html#create-project-console-source). ([03/26/2024](https://aws.amazon.com/about-aws/whats-new/2024/03/aws-codebuild-gitlab-gitlab-self-managed/)) `[AWS Built]`
Documentation and References:
- [Creating a GitLab CodeStar Connection to a GitLab.com Project](https://docs.aws.amazon.com/codepipeline/latest/userguide/connections-gitlab-managed.html)
- [Creating a AWS CodeStar Connection for GitLab Self-Managed or GitLab Dedicated](https://docs.aws.amazon.com/codepipeline/latest/userguide/connections-gitlab-managed.html) (must allow Internet Ingress from AWS or use a VPC connection)
#### AWS CodePipeline Integrations
[AWS CodePipeline Integration](https://docs.aws.amazon.com/codepipeline/latest/userguide/connections-gitlab.html) - by using GitLab as CodeStar Connections source for CodePipeline, additional AWS service integrations are available. ([12/28/2023](https://aws.amazon.com/about-aws/whats-new/2023/12/codepipeline-gitlab-self-managed/)) `[AWS Built]`
AWS Services that are supported by an AWS CodePipeline integration:
- **Amazon SageMaker MLOps Projects** are created via CodePipeline ([as noted here](https://docs.aws.amazon.com/sagemaker/latest/dg/sagemaker-projects-walkthrough-3rdgit.html#sagemaker-proejcts-walkthrough-connect-3rdgit)), there is not any specific documentation about GitLab because it just uses any GitLab CodeStar Connection that has been created in the account. ([12/28/2023](https://aws.amazon.com/about-aws/whats-new/2023/12/codepipeline-gitlab-self-managed/)) `[AWS Built]`
Documentation and References:
- [Creating a GitLab CodePipeline Integration to a GitLab.com Project](https://docs.aws.amazon.com/codepipeline/latest/userguide/connections-gitlab-managed.html)
- [Creating a AWS CodePipeline Integration for GitLab Self-Managed or GitLab Dedicated](https://docs.aws.amazon.com/codepipeline/latest/userguide/connections-gitlab-managed.html) (must allow Internet Ingress from AWS or use a VPC connection)
#### CodeStar Connections enabled AWS services that are not yet supported for GitLab
- **AWS CloudFormation** publishing of public extensions - not yet supported. `[AWS Built]`
- **Amazon CodeGuru Reviewer Repositories** - not yet supported. `[AWS Built]`
- **AWS App Runner** - not yet supported. `[AWS Built]`
#### Custom GitLab Integration in AWS Services
- **Amazon SageMaker Notebooks** [allow Git repositories to be specified by the Git clone URL](https://docs.aws.amazon.com/sagemaker/latest/dg/nbi-git-resource.html) and configuration of a secret - so GitLab is configurable. ([12/28/2023](https://aws.amazon.com/about-aws/whats-new/2023/12/codepipeline-gitlab-self-managed/)) `[AWS Configuration]`
- **AWS Amplify** - [uses a Git integration mechanism designed by the AWS Amplify team](https://docs.aws.amazon.com/amplify/latest/userguide/getting-started.html). `[AWS Built]`
- **AWS Glue Notebook Jobs** support for GitLab repository URL with personal access token (PAT) authentication at the "job" level. ([10/03/2022](https://aws.amazon.com/about-aws/whats-new/2022/10/aws-glue-git-integration/)) [AWS Docs about configuring GitLab](https://docs.aws.amazon.com/glue/latest/dg/edit-job-add-source-control-integration.html) `[AWS Configuration]`
#### Other SCM Integration Options
- [GitLab Push Mirroring to CodeCommit](../../../user/project/repository/mirror/push.md#set-up-a-push-mirror-from-gitlab-to-aws-codecommit) Workaround enables GitLab repositories to leverage CodePipeline SCM Triggers. GitLab can already leverage S3 and Container Triggers for CodePipeline. This work around enabled CodePipeline capabilities since it was documented. (06/06/2020) `[GitLab Configuration]`
See [CD and Operations Integrations](#cd-and-operations-integrations) below for Continuous Deployment (CD) specific integrations that are also available.
### CI Integrations
- **Direct CI Integrations That Use Keys, IAM or OIDC/JWT to Authenticate to AWS Services from GitLab Runners**
- **Amazon CodeGuru Reviewer CI workflows using GitLab CI** - can be done, not yet documented.`[AWS Solution]` `[CI Solution]`
- [Amazon CodeGuru Secure Scanning using GitLab CI](https://docs.aws.amazon.com/codeguru/latest/security-ug/get-started-gitlab.html) ([06/13/2022](https://aws.amazon.com/about-aws/whats-new/2023/06/amazon-codeguru-security-available-preview/)) `[AWS Solution]` `[CI Solution]`
### CD and Operations Integrations
- **AWS CodeDeploy Integration** - through CodePipeline support discussed previously in the SCM integrations. This capability allows GitLab to interface with [this list of advanced deployment subsystems in AWS](https://docs.aws.amazon.com/codepipeline/latest/userguide/integrations-action-type.html#integrations-deploy). ([12/28/2023](https://aws.amazon.com/about-aws/whats-new/2023/12/codepipeline-gitlab-self-managed/)) `[AWS Built]`
- **AWS SAM Pipelines** - [pipelines support for GitLab](https://aws.amazon.com/about-aws/whats-new/2021/07/simplify-ci-cd-configuration-serverless-applications-your-favorite-ci-cd-system-public-preview/). (7/31/2021)
- [Integrate EKS clusters for application deployment](../../../user/infrastructure/clusters/connect/new_eks_cluster.md). `[GitLab Built]`
- [GitLab pushing a build Artifact to a CodePipeline monitored S3 location](https://docs.aws.amazon.com/codepipeline/latest/userguide/pipelines-about-starting.html#change-detection-methods) `[AWS Built]`
- [GitLab Pushing a container to a CodePipeline monitored AWS ECR](https://docs.aws.amazon.com/codepipeline/latest/userguide/pipelines-about-starting.html#change-detection-methods) `[AWS Built]`
- [Use GitLab.com's Container Registry as an Upstream Registry for AWS ECR via Pull-Through Cache Rules](https://docs.aws.amazon.com/AmazonECR/latest/userguide/pull-through-cache-creating-rule.html) [Configuration Tutorial](tutorials/aws_ecr_pull_through_cache.md) `[AWS Built]`
## End-to-End Solutions for development and deployment of specific development frameworks or ecosystems
Generally solutions demonstrate end-to-end capabilities for the development framework - leveraging all relevant integration techniques to show the art of maximum value for using GitLab and AWS together.
### Serverless
- [Enterprise DevOps Blueprint: Serverless Framework Apps on AWS](https://gitlab.com/guided-explorations/aws/serverless/serverless-framework-aws) - working example code and tutorials. `[GitLab Solution]` `[CI Solution]`
- [Tutorial: Serverless Framework Deployment to AWS with GitLab Serverless SAST Scanning](https://gitlab.com/guided-explorations/aws/serverless/serverless-framework-aws/-/blob/master/TUTORIAL.md) `[GitLab Solution]` `[CI Solution]`
- [Tutorial: Secure Serverless Framework Development with GitLab Security Policy Approval Rules and Managed DevOps Environments](https://gitlab.com/guided-explorations/aws/serverless/serverless-framework-aws/-/blob/prod/TUTORIAL2-SecurityAndManagedEnvs.md?ref_type=heads) `[GitLab Solution]` `[CI Solution]`
### Terraform
- [Enterprise DevOps Blueprint: Terraform Deployment to AWS](https://gitlab.com/guided-explorations/aws/terraform/terraform-web-server-cluster)
- [Tutorial: Terraform Deployment to AWS with GitLab IaC SAST Scanning](https://gitlab.com/guided-explorations/aws/terraform/terraform-web-server-cluster/-/blob/prod/TUTORIAL.md) `[GitLab Solution]` `[CI Solution]`
- [Terraform Deployment to AWS with GitLab Security Policy Approval Rules and Managed DevOps Environments](https://gitlab.com/guided-explorations/aws/terraform/terraform-web-server-cluster/-/blob/prod/TUTORIAL2-SecurityAndManagedEnvs.md) `[GitLab Solution]` `[CI Solution]`
### CloudFormation
[CloudFormation Development and Deployment With GitLab Lifecycle Managed DevOps Environments Working Code](https://gitlab.com/guided-explorations/aws/cloudformation-deploy) `[GitLab Solution]` `[CI Solution]`
### CDK
- [Building Cross-Account Deployment in GitLab Pipelines Using AWS CDK](https://aws.amazon.com/blogs/apn/building-cross-account-deployment-in-gitlab-pipelines-using-aws-cdk/) `[AWS Solution]` `[CI Solution]`
### .NET on AWS
- [Working Example Code for Scaling .NET Framework 4.x Runners on AWS](https://gitlab.com/guided-explorations/aws/dotnet-aws-toolkit) `[GitLab Solution]` `[CI Solution]`
- [Video Walkthrough of Code and Building a .NET Framework 4.x Project](https://www.youtube.com/watch?v=_4r79ZLmDuo) `[GitLab Solution]` `[CI Solution]`
## System to system integration of GitLab and AWS
AWS Identity providers (IDP) can be configured to authenticate into GitLab or GitLab can function as an IDP into AWS accounts.
Top-level groups on GitLab.com are also known as "Namespaces" and naming one after your company is the first step to setting up a tenant for your organization on GitLab.com. Namespaces can be configured for special functionality like SSO which then integrates your IDP into GitLab.
### User authentication and authorization between GitLab and AWS
- [SAML SSO for GitLab.com groups](../../../user/group/saml_sso/_index.md) `[GitLab Configuration]` - GitLab.com only
- [Integrate LDAP with GitLab](../../../administration/auth/ldap/_index.md) `[GitLab Configuration]` - GitLab Self-Managed only
### Runner workload authentication and authorization integration
- [Runner Job Authentication using Open ID & JWT Authentication](../../../ci/cloud_services/aws/_index.md). `[GitLab Built]`
- [Configure OpenID Connect between GitLab and AWS](https://gitlab.com/guided-explorations/aws/configure-openid-connect-in-aws) `[GitLab Solution]` `[CI Solution]`
- [OIDC and Multi-Account Deployment with GitLab and ECS](https://gitlab.com/guided-explorations/aws/oidc-and-multi-account-deployment-with-ecs) `[GitLab Solution]` `[CI Solution]`
## GitLab infrastructure workloads deployed on AWS
While GitLab can be deployed on a single box for up to 500 users, when it is horizontally scaled for very large user counts like 50,000 it expands into being a complex, many tiered platform that benefits from deployment to AWS. GitLab is supports and is regularly tested being backed by AWS services. GitLab is deployable to Ec2 for traditional scaling and to AWS EKS in a Cloud Native Hybrid implementation. It is called Hybrid because specific service layers cannot be placed in a container cluster due to the workload shapes that are common to Git (and common to how Git processes behave handles that workload variety).
### GitLab Instance Compute & Operations Integration
- Installing GitLab Self-Managed on AWS
- [AWS Services that can be used when deploying GitLab](gitlab_instance_on_aws.md)
- GitLab Single EC2 Instance. `[GitLab Built]`
- [Using 5 Seat AWS marketplace subscription](gitlab_single_box_on_aws.md#marketplace-subscription)
- [Using Prepared AMIs](gitlab_single_box_on_aws.md#official-gitlab-releases-as-amis) - Bring Your Own License for Enterprise Edition.
- GitLab Cloud Native Hybrid Scaled on AWS EKS and Paas. `[GitLab Built]`
- [Using GitLab Environment Toolkit (GET)](https://gitlab.com/gitlab-org/gitlab-environment-toolkit) - `[GitLab Solution]`
- GitLab Instance Scaled on AWS EC2 and PaaS. `[GitLab Built]`
- [Using GitLab Environment Toolkit (GET)](https://gitlab.com/gitlab-org/gitlab-environment-toolkit) - `[GitLab Solution]`
- [Amazon Managed Grafana](https://docs.aws.amazon.com/grafana/latest/userguide/gitlab-AMG-datasource.html) for GitLab Self-Managed Prometheus metrics. `[AWS Built]`
### GitLab Runner on AWS Compute
- [GitLab Runner Autoscaler](https://docs.gitlab.com/runner/runner_autoscale/) - core technology built by GitLab Runner team. `[GitLab Built]`
- [GitLab Runner Infrastructure Toolkit (GRIT)](https://gitlab.com/gitlab-org/ci-cd/runner-tools/grit) - managed infrastructure as code stewarded by the GitLab Runner team. Needed to deploy things like the GitLab Runner Autoscaler. `[GitLab Built]`
- [Autoscaling GitLab Runner on AWS EC2](https://docs.gitlab.com/runner/configuration/runner_autoscale_aws/). `[GitLab Built]`
- [GitLab HA Scaling Runner Vending Machine for AWS EC2 ASG](https://gitlab.com/guided-explorations/aws/gitlab-runner-autoscaling-aws-asg/). `[GitLab Solution]`
- Runner vending machine training resources.
- [GitLab EKS Fargate Runners](https://gitlab.com/guided-explorations/aws/eks-runner-configs/gitlab-runner-eks-fargate/-/blob/main/README.md). `[GitLab Solution]`
|
https://docs.gitlab.com/solutions/cloud/gitlab_aws_partner_designations
|
https://gitlab.com/gitlab-org/gitlab/-/tree/master/doc/solutions/cloud/gitlab_aws_partner_designations.md
|
2025-08-13
|
doc/solutions/cloud/aws
|
[
"doc",
"solutions",
"cloud",
"aws"
] |
gitlab_aws_partner_designations.md
|
Solutions Architecture
|
Solutions Architecture
|
This page is owned by the Solutions Architecture team.
|
GitLab partnership certifications and designations from AWS
|
GitLab partnership certifications and designations from AWS.
|
The certifications and designations outlined here can be validated on [GitLabs partner page at AWS](https://partners.amazonaws.com/partners/001E0000018YWFfIAO/GitLab,%20Inc.).
All AWS partner qualifications require submission and validation of extensive checklists and submission of backing evidence that AWS utilizes to determine whether to grant the qualification.
## DevOps Software / ISV Competency
This competency validates that GitLab delivers DevOps solutions that work with and on AWS. [AWS Program Information](https://aws.amazon.com/devops/partner-solutions/)
## DevSecOps Specialty Category
The DevSecOps qualification is a category of the DevOps Software Competency that demonstrates that GitLab is a substantial solution in helping organizations meet their DevSecOps maturity goals. GitLab was reviewed for meeting these additional qualifications before being granted this designation. [AWS Program Information](https://aws.amazon.com/blogs/apn/aws-devops-competency-expands-to-include-devsecops-category/) [GitLab Announcement](https://about.gitlab.com/blog/2023/09/25/aws-devsecops-competency-partner/)
## Public Sector Partner
This designation indicates that GitLab has been deemed qualified to work with AWS Public Sector customers. GitLab has a dedicated organization to address public sector specific needs. [AWS Program Information](https://aws.amazon.com/partners/programs/public-sector/)
## AWS Graviton
GitLab Instances and Runners have been tested and work on AWS Graviton. For Amazon Linux we maintain YUM packages for ARM architecture. [AWS Program Information](https://aws.amazon.com/ec2/graviton/partners/)
## Amazon Linux Ready
GitLab Instances and Runner have been validated on Amazon Linux 2 and 2023 - this includes YUM packages and package repositories for both and over 2300 CI tests for both before packaging. [AWS Program Information](https://aws.amazon.com/amazon-linux/partners/)
## AWS Marketplace Seller
GitLab is a marketplace seller and you can purchase and deploy it through AWS marketplace [AWS Program Information](https://aws.amazon.com/marketplace/partners/management-tour)
|
---
stage: Solutions Architecture
group: Solutions Architecture
info: This page is owned by the Solutions Architecture team.
description: GitLab partnership certifications and designations from AWS.
title: GitLab partnership certifications and designations from AWS
breadcrumbs:
- doc
- solutions
- cloud
- aws
---
The certifications and designations outlined here can be validated on [GitLabs partner page at AWS](https://partners.amazonaws.com/partners/001E0000018YWFfIAO/GitLab,%20Inc.).
All AWS partner qualifications require submission and validation of extensive checklists and submission of backing evidence that AWS utilizes to determine whether to grant the qualification.
## DevOps Software / ISV Competency
This competency validates that GitLab delivers DevOps solutions that work with and on AWS. [AWS Program Information](https://aws.amazon.com/devops/partner-solutions/)
## DevSecOps Specialty Category
The DevSecOps qualification is a category of the DevOps Software Competency that demonstrates that GitLab is a substantial solution in helping organizations meet their DevSecOps maturity goals. GitLab was reviewed for meeting these additional qualifications before being granted this designation. [AWS Program Information](https://aws.amazon.com/blogs/apn/aws-devops-competency-expands-to-include-devsecops-category/) [GitLab Announcement](https://about.gitlab.com/blog/2023/09/25/aws-devsecops-competency-partner/)
## Public Sector Partner
This designation indicates that GitLab has been deemed qualified to work with AWS Public Sector customers. GitLab has a dedicated organization to address public sector specific needs. [AWS Program Information](https://aws.amazon.com/partners/programs/public-sector/)
## AWS Graviton
GitLab Instances and Runners have been tested and work on AWS Graviton. For Amazon Linux we maintain YUM packages for ARM architecture. [AWS Program Information](https://aws.amazon.com/ec2/graviton/partners/)
## Amazon Linux Ready
GitLab Instances and Runner have been validated on Amazon Linux 2 and 2023 - this includes YUM packages and package repositories for both and over 2300 CI tests for both before packaging. [AWS Program Information](https://aws.amazon.com/amazon-linux/partners/)
## AWS Marketplace Seller
GitLab is a marketplace seller and you can purchase and deploy it through AWS marketplace [AWS Program Information](https://aws.amazon.com/marketplace/partners/management-tour)
|
https://docs.gitlab.com/solutions/cloud/gitlab_single_box_on_aws
|
https://gitlab.com/gitlab-org/gitlab/-/tree/master/doc/solutions/cloud/gitlab_single_box_on_aws.md
|
2025-08-13
|
doc/solutions/cloud/aws
|
[
"doc",
"solutions",
"cloud",
"aws"
] |
gitlab_single_box_on_aws.md
|
Solutions Architecture
|
Solutions Architecture
|
This page is owned by the Solutions Architecture team.
|
Provision GitLab on a single EC2 instance in AWS
| null |
{{< details >}}
- Tier: Free, Premium, Ultimate
- Offering: GitLab Self-Managed
{{< /details >}}
If you want to provision a single GitLab instance on AWS, you have two options:
- The marketplace subscription
- The official GitLab AMIs
## Marketplace subscription
GitLab provides a 5 user subscription as an AWS Marketplace subscription to help teams of all sizes to get started with an Ultimate licensed instance in record time. The Marketplace subscription can be easily upgraded to any GitLab licensing via an AWS Marketplace Private Offer, with the convenience of continued AWS billing. No migration is necessary to obtain a larger, non-time based license from GitLab. Per-minute licensing is automatically removed when you accept the private offer.
For a tutorial on provisioning a GitLab Instance via a Marketplace Subscription, [use this tutorial](https://gitlab.awsworkshop.io/040_partner_setup.html). The tutorial links to the [GitLab Ultimate Marketplace Listing](https://aws.amazon.com/marketplace/pp/prodview-g6ktjmpuc33zk), but you can also use the [GitLab Premium Marketplace Listing](https://aws.amazon.com/marketplace/pp/prodview-amk6tacbois2k) to provision an instance.
## Official GitLab releases as AMIs
GitLab produces Amazon Machine Images (AMI) during the regular release process. The AMIs can be used for single instance GitLab installation or, by configuring `/etc/gitlab/gitlab.rb`, can be specialized for specific GitLab service roles (for example a Gitaly server). Older releases remain available and can be used to migrate an older GitLab server to AWS.
Initial licensing can either be the Free Enterprise License (EE) or the open source Community Edition (CE). The Enterprise Edition provides the easiest path forward to a licensed version if the need arises.
Currently the Amazon AMI uses the Amazon prepared Ubuntu AMI (x86 and ARM are available) as its starting point.
{{< alert type="note" >}}
When deploying a GitLab instance using the official AMI, the root password to the instance is the EC2 **Instance** ID (not the AMI ID). This way of setting the root account password is specific to official GitLab published AMIs ONLY.
{{< /alert >}}
Instances running on Community Edition (CE) require a migration to Enterprise Edition (EE) to subscribe to the GitLab Premium or Ultimate plan. If you want to pursue a subscription, using the Free-forever plan of Enterprise Edition is the least disruptive method.
{{< alert type="note" >}}
Because any given GitLab upgrade might involve data disk updates or database schema upgrades, swapping out the AMI is not sufficient for taking upgrades.
{{< /alert >}}
1. Sign in to the AWS Web Console, so that selecting the links in the following step take you directly to the AMI list.
1. Pick the edition you want:
- [GitLab Enterprise Edition](https://console.aws.amazon.com/ec2/v2/home?region=us-east-1#Images:visibility=public-images;owner=782774275127;search=GitLab%20EE;sort=desc:name): If you want to unlock the enterprise features, a license is needed.
- [GitLab Community Edition](https://console.aws.amazon.com/ec2/v2/home?region=us-east-1#Images:visibility=public-images;owner=782774275127;search=GitLab%20CE;sort=desc:name): The open source version of GitLab.
- [GitLab Premium or Ultimate Marketplace (pre-licensed)](https://console.aws.amazon.com/ec2/v2/home?region=us-east-1#Images:visibility=public-images;source=Marketplace;search=GitLab%20EE;sort=desc:name): 5 user license built into per-minute billing.
1. AMI IDs are unique per region. After you've loaded any of these editions, in the upper-right corner, select the desired target region of the console to see the appropriate AMIs.
1. After the console is loaded, you can add additional search criteria to narrow further. For instance, type `13.` to find only 13.x versions.
1. To launch an EC2 Machine with one of the listed AMIs, check the box at the start of the relevant row, and select **Launch** near the top of left of the page.
|
---
stage: Solutions Architecture
group: Solutions Architecture
info: This page is owned by the Solutions Architecture team.
title: Provision GitLab on a single EC2 instance in AWS
breadcrumbs:
- doc
- solutions
- cloud
- aws
---
{{< details >}}
- Tier: Free, Premium, Ultimate
- Offering: GitLab Self-Managed
{{< /details >}}
If you want to provision a single GitLab instance on AWS, you have two options:
- The marketplace subscription
- The official GitLab AMIs
## Marketplace subscription
GitLab provides a 5 user subscription as an AWS Marketplace subscription to help teams of all sizes to get started with an Ultimate licensed instance in record time. The Marketplace subscription can be easily upgraded to any GitLab licensing via an AWS Marketplace Private Offer, with the convenience of continued AWS billing. No migration is necessary to obtain a larger, non-time based license from GitLab. Per-minute licensing is automatically removed when you accept the private offer.
For a tutorial on provisioning a GitLab Instance via a Marketplace Subscription, [use this tutorial](https://gitlab.awsworkshop.io/040_partner_setup.html). The tutorial links to the [GitLab Ultimate Marketplace Listing](https://aws.amazon.com/marketplace/pp/prodview-g6ktjmpuc33zk), but you can also use the [GitLab Premium Marketplace Listing](https://aws.amazon.com/marketplace/pp/prodview-amk6tacbois2k) to provision an instance.
## Official GitLab releases as AMIs
GitLab produces Amazon Machine Images (AMI) during the regular release process. The AMIs can be used for single instance GitLab installation or, by configuring `/etc/gitlab/gitlab.rb`, can be specialized for specific GitLab service roles (for example a Gitaly server). Older releases remain available and can be used to migrate an older GitLab server to AWS.
Initial licensing can either be the Free Enterprise License (EE) or the open source Community Edition (CE). The Enterprise Edition provides the easiest path forward to a licensed version if the need arises.
Currently the Amazon AMI uses the Amazon prepared Ubuntu AMI (x86 and ARM are available) as its starting point.
{{< alert type="note" >}}
When deploying a GitLab instance using the official AMI, the root password to the instance is the EC2 **Instance** ID (not the AMI ID). This way of setting the root account password is specific to official GitLab published AMIs ONLY.
{{< /alert >}}
Instances running on Community Edition (CE) require a migration to Enterprise Edition (EE) to subscribe to the GitLab Premium or Ultimate plan. If you want to pursue a subscription, using the Free-forever plan of Enterprise Edition is the least disruptive method.
{{< alert type="note" >}}
Because any given GitLab upgrade might involve data disk updates or database schema upgrades, swapping out the AMI is not sufficient for taking upgrades.
{{< /alert >}}
1. Sign in to the AWS Web Console, so that selecting the links in the following step take you directly to the AMI list.
1. Pick the edition you want:
- [GitLab Enterprise Edition](https://console.aws.amazon.com/ec2/v2/home?region=us-east-1#Images:visibility=public-images;owner=782774275127;search=GitLab%20EE;sort=desc:name): If you want to unlock the enterprise features, a license is needed.
- [GitLab Community Edition](https://console.aws.amazon.com/ec2/v2/home?region=us-east-1#Images:visibility=public-images;owner=782774275127;search=GitLab%20CE;sort=desc:name): The open source version of GitLab.
- [GitLab Premium or Ultimate Marketplace (pre-licensed)](https://console.aws.amazon.com/ec2/v2/home?region=us-east-1#Images:visibility=public-images;source=Marketplace;search=GitLab%20EE;sort=desc:name): 5 user license built into per-minute billing.
1. AMI IDs are unique per region. After you've loaded any of these editions, in the upper-right corner, select the desired target region of the console to see the appropriate AMIs.
1. After the console is loaded, you can add additional search criteria to narrow further. For instance, type `13.` to find only 13.x versions.
1. To launch an EC2 Machine with one of the listed AMIs, check the box at the start of the relevant row, and select **Launch** near the top of left of the page.
|
https://docs.gitlab.com/solutions/cloud/aws/aws_ecr_pull_through_cache
|
https://gitlab.com/gitlab-org/gitlab/-/tree/master/doc/solutions/cloud/aws/aws_ecr_pull_through_cache.md
|
2025-08-13
|
doc/solutions/cloud/aws/tutorials
|
[
"doc",
"solutions",
"cloud",
"aws",
"tutorials"
] |
aws_ecr_pull_through_cache.md
|
Solutions Architecture
|
Solutions Architecture
|
This page is owned by the Solutions Architecture team.
|
Tutorial: Configuring AWS ECR Pull Through Cache Rules for Authenticated Access to GitLab.com Projects
|
Integrations Solutions Index for GitLab and AWS.
|
1. Open the Amazon ECR console at <https://console.aws.amazon.com/ecr/>.
1. From the navigation bar, choose the Region to configure your private registry settings in.
1. In the navigation pane, choose Private registry, Pull through cache.
1. On the Pull through cache configuration page, choose Add rule.
On Step 1: Specify a source page, for Registry, choose GitLab Container Registry, Next.
On Step 2: Configure authentication page, for Upstream credentials, you must store your authentication credentials for GitLab Container Registry in an AWS Secrets Manager secret. You can specify an existing secret or use the Amazon ECR console to create a new secret.
To use an existing secret, choose Use an existing AWS secret. For Secret name use the drop down to select your existing secret, and then choose Next. For more information on creating a Secrets Manager secret using the Secrets Manager console, see Storing your upstream repository credentials in an AWS Secrets Manager secret.
{{< alert type="note" >}}
The AWS Management Console only displays Secrets Manager secrets with names using the ecr-pullthroughcache/ prefix. The secret must also be in the same account and Region that the pull through cache rule is created in.
{{< /alert >}}
To create a new secret, choose Create an AWS secret, do the following, then choose Next.
For Secret name, specify a descriptive name for the secret. Secret names must contain 1-512 Unicode characters.
For GitLab Container Registry username, specify your GitLab Container Registry username.
For GitLab Container Registry access token, specify your GitLab Container Registry access token. To follow principles of least privilege, create a Group Access Token with the Guest role and only the `read_registry` scope.
On the Step 3: Specify a destination page, for Amazon ECR repository prefix, specify the repository namespace to use when caching images pulled from the source public registry and then choose Next.
By default, a namespace is populated but a custom namespace can be specified as well.
On the Step 4: Review and create page, review the pull through cache rule configuration and then choose Create.
Repeat the previous step for each pull through cache you want to create. The pull through cache rules are created separately for each Region.
To validate that your ECR Pull Through Cache rule was created successfully, you can run the following command via the AWS CLI to validate the rule:
```shell
aws ecr validate-pull-through-cache-rule \
--ecr-repository-prefix ecr-public \
--region us-east-2
```
To validate that your ECR Pull Through Cache rule provides pull-through access to the GitLab.com upstream registry, you can to validate by running a `docker pull` command:
```shell
docker pull aws_account_id.dkr.ecr.region.amazonaws.com/{destination-namespace e.g. gitlab-ef1b}/{path to Gitlab.com project/group where image is hosted}/image_name:tag
```
Example `docker pull` command:
```shell
docker pull aws_account_id.dkr.ecr.region.amazonaws.com/gitlab-ef1b/guided-explorations/ci-components/working-code-examples/kaniko-component-multiarch-build:latest
```
|
---
stage: Solutions Architecture
group: Solutions Architecture
info: This page is owned by the Solutions Architecture team.
description: Integrations Solutions Index for GitLab and AWS.
title: 'Tutorial: Configuring AWS ECR Pull Through Cache Rules for Authenticated Access
to GitLab.com Projects'
breadcrumbs:
- doc
- solutions
- cloud
- aws
- tutorials
---
1. Open the Amazon ECR console at <https://console.aws.amazon.com/ecr/>.
1. From the navigation bar, choose the Region to configure your private registry settings in.
1. In the navigation pane, choose Private registry, Pull through cache.
1. On the Pull through cache configuration page, choose Add rule.
On Step 1: Specify a source page, for Registry, choose GitLab Container Registry, Next.
On Step 2: Configure authentication page, for Upstream credentials, you must store your authentication credentials for GitLab Container Registry in an AWS Secrets Manager secret. You can specify an existing secret or use the Amazon ECR console to create a new secret.
To use an existing secret, choose Use an existing AWS secret. For Secret name use the drop down to select your existing secret, and then choose Next. For more information on creating a Secrets Manager secret using the Secrets Manager console, see Storing your upstream repository credentials in an AWS Secrets Manager secret.
{{< alert type="note" >}}
The AWS Management Console only displays Secrets Manager secrets with names using the ecr-pullthroughcache/ prefix. The secret must also be in the same account and Region that the pull through cache rule is created in.
{{< /alert >}}
To create a new secret, choose Create an AWS secret, do the following, then choose Next.
For Secret name, specify a descriptive name for the secret. Secret names must contain 1-512 Unicode characters.
For GitLab Container Registry username, specify your GitLab Container Registry username.
For GitLab Container Registry access token, specify your GitLab Container Registry access token. To follow principles of least privilege, create a Group Access Token with the Guest role and only the `read_registry` scope.
On the Step 3: Specify a destination page, for Amazon ECR repository prefix, specify the repository namespace to use when caching images pulled from the source public registry and then choose Next.
By default, a namespace is populated but a custom namespace can be specified as well.
On the Step 4: Review and create page, review the pull through cache rule configuration and then choose Create.
Repeat the previous step for each pull through cache you want to create. The pull through cache rules are created separately for each Region.
To validate that your ECR Pull Through Cache rule was created successfully, you can run the following command via the AWS CLI to validate the rule:
```shell
aws ecr validate-pull-through-cache-rule \
--ecr-repository-prefix ecr-public \
--region us-east-2
```
To validate that your ECR Pull Through Cache rule provides pull-through access to the GitLab.com upstream registry, you can to validate by running a `docker pull` command:
```shell
docker pull aws_account_id.dkr.ecr.region.amazonaws.com/{destination-namespace e.g. gitlab-ef1b}/{path to Gitlab.com project/group where image is hosted}/image_name:tag
```
Example `docker pull` command:
```shell
docker pull aws_account_id.dkr.ecr.region.amazonaws.com/gitlab-ef1b/guided-explorations/ci-components/working-code-examples/kaniko-component-multiarch-build:latest
```
|
https://docs.gitlab.com/solutions/cloud/aws/tutorials
|
https://gitlab.com/gitlab-org/gitlab/-/tree/master/doc/solutions/cloud/aws/_index.md
|
2025-08-13
|
doc/solutions/cloud/aws/tutorials
|
[
"doc",
"solutions",
"cloud",
"aws",
"tutorials"
] |
_index.md
|
Solutions Architecture
|
Solutions Architecture
|
This page is owned by the Solutions Architecture team.
|
AWS Solutions
| null |
This documentation covers solutions relating to leveraging GitLab with and on Amazon Web Services (AWS).
- [Configuring AWS ECR Pull Through Cache for Authenticated Access to GitLab.com Projects](aws_ecr_pull_through_cache.md)
|
---
stage: Solutions Architecture
group: Solutions Architecture
info: This page is owned by the Solutions Architecture team.
title: AWS Solutions
breadcrumbs:
- doc
- solutions
- cloud
- aws
- tutorials
---
This documentation covers solutions relating to leveraging GitLab with and on Amazon Web Services (AWS).
- [Configuring AWS ECR Pull Through Cache for Authenticated Access to GitLab.com Projects](aws_ecr_pull_through_cache.md)
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.