# GraphQL
> 原文：[https://docs.gitlab.com/ee/development/fe_guide/graphql.html](https://docs.gitlab.com/ee/development/fe_guide/graphql.html)
* [Getting Started](#getting-started)
* [Helpful Resources](#helpful-resources)
* [Libraries](#libraries)
* [Tooling](#tooling)
* [Apollo GraphQL VS Code extension](#apollo-graphql-vs-code-extension)
* [Exploring the GraphQL API](#exploring-the-graphql-api)
* [Apollo Client](#apollo-client)
* [GraphQL Queries](#graphql-queries)
* [Fragments](#fragments)
* [Usage in Vue](#usage-in-vue)
* [Local state with Apollo](#local-state-with-apollo)
* [Mocking API response with local Apollo cache](#mocking-api-response-with-local-apollo-cache)
* [Using with Vuex](#using-with-vuex)
* [Feature flags in queries](#feature-flags-in-queries)
* [Manually triggering queries](#manually-triggering-queries)
* [Working with pagination](#working-with-pagination)
* [Using `fetchMore` method in components](#using-fetchmore-method-in-components)
* [Testing](#testing)
* [Mocking response as component data](#mocking-response-as-component-data)
* [Testing loading state](#testing-loading-state)
* [Testing Apollo components](#testing-apollo-components)
* [Handling errors](#handling-errors)
* [Top-level errors](#top-level-errors)
* [Handling top-level errors](#handling-top-level-errors)
* [Errors-as-data](#errors-as-data)
* [Handling errors-as-data](#handling-errors-as-data)
* [Usage outside of Vue](#usage-outside-of-vue)
# GraphQL[](#graphql "Permalink")
## Getting Started[](#getting-started "Permalink")
### Helpful Resources[](#helpful-resources "Permalink")
**一般資源**:
* [?? Official Introduction to GraphQL](https://s0graphql0org.icopy.site/learn/)
* [?? Official Introduction to Apollo](https://www.apollographql.com/docs/tutorial/introduction/)
**GitLab 上的 GraphQL**:
* [?? GitLab Unfiltered GraphQL playlist](https://www.youtube.com/watch?v=wHPKZBDMfxE&list=PL05JrBw4t0KpcjeHjaRMB7IGB2oDWyJzv)
* [GitLab 上的 GraphQL：深潛](../api_graphql_styleguide.html#deep-dive) （視頻）作者 Nick Thomas
* GitLab 上 GraphQL 的歷史概述（不是特定于前端的）
* [使用 GraphQL 和 Vue Apollo 進行 GitLab 功能演練](https://www.youtube.com/watch?v=6yYp2zB7FrM) （視頻），作者 Natalia Tepluhina
* 使用 GraphQL 在 GitLab 中實現前端功能的真實示例
* [GitLab 上的客戶端 GraphQL 的歷史](https://www.youtube.com/watch?v=mCKRJxvMnf0) （視頻）Illya Klymov 和 Natalia Tepluhina
* Natalia Tepluhina [從 Vuex 到 Apollo](https://www.youtube.com/watch?v=9knwu87IfU8) （視頻）
* 關于何時阿波羅可能比 Vuex 更好的選擇以及如何進行過渡的有用概述
* [?? Vuex -> Apollo Migration: a proof-of-concept project](https://gitlab.com/ntepluhina/vuex-to-apollo/blob/master/README.md)
* 一系列示例展示了使用 Vue + GraphQL +（Vuex 或 Apollo）應用進行狀態管理的可能方法
### Libraries[](#libraries "Permalink")
當使用 GraphQL 進行前端開發時，我們使用[Apollo](https://www.apollographql.com/) （特別是[Apollo Client](https://www.apollographql.com/docs/react/) ）和[Vue Apollo](https://github.com/vuejs/vue-apollo) .
如果在 Vue 應用程序中使用 GraphQL，則" Vue 中的[用法"](#usage-in-vue)部分可以幫助您學習如何集成 Vue Apollo.
對于其他用例，請查看[Vue 外部](#usage-outside-of-vue)的[用法](#usage-outside-of-vue)部分.
### Tooling[](#tooling "Permalink")
* [Apollo Client Devtools](https://github.com/apollographql/apollo-client-devtools)
#### [Apollo GraphQL VS Code extension](https://marketplace.visualstudio.com/items?itemName=apollographql.vscode-apollo)[](#apollo-graphql-vs-code-extension "Permalink")
如果使用 VS Code，則 Apollo GraphQL 擴展名支持`.graphql`文件中的自動完成. 若要設置 GraphQL 擴展，請按照下列步驟操作：
1. 將`apollo.config.js`文件添加到`gitlab`本地目錄的根目錄中.
2. 用以下內容填充文件：
```
module.exports = {
client: {
includes: ['./app/assets/javascripts/**/*.graphql', './ee/app/assets/javascripts/**/*.graphql'],
service: {
name: 'GitLab',
localSchemaFile: './doc/api/graphql/reference/gitlab_schema.graphql',
},
},
};
```
3. 重新啟動 VS Code.
### Exploring the GraphQL API[](#exploring-the-graphql-api "Permalink")
我們 GraphQL API 可以通過 GraphiQL 在您的實例的探索`/-/graphql-explorer`或[GitLab.com](https://gitlab.com/-/graphql-explorer) . 如有需要，請查閱《 [GitLab GraphQL API 參考》文檔](../../api/graphql/reference) .
您可以在 GraphiQL 的**文檔瀏覽器**的右側檢查所有現有的查詢和變異. 也可以直接在左選項卡上編寫查詢和變異，然后單擊左上角的**執行查詢**按鈕來檢查其執行情況：
[](img/graphiql_explorer_v12_4.png)
## Apollo Client[](#apollo-client "Permalink")
為了保存在不同的應用程序中創建的重復客戶端，我們使用[默認客戶端](https://gitlab.com/gitlab-org/gitlab/blob/master/app/assets/javascripts/lib/graphql.js) . 這將使用正確的 URL 設置 Apollo 客戶端，并設置 CSRF 標頭.
默認客戶端接受兩個參數： `resolvers`和`config` .
* 創建`resolvers`參數以接受用于[本地狀態管理](#local-state-with-apollo)查詢和突變的 resolvers 對象
* `config`參數采用配置設置的對象：
* `cacheConfig`字段接受設置的可選對象以[自定義 Apollo 緩存](https://www.apollographql.com/docs/react/caching/cache-configuration/#configuring-the-cache)
* `baseUrl`允許我們傳遞與主端點不同的 GraphQL 端點的 URL（即`${gon.relative_url_root}/api/graphql` ）
* `assumeImmutableResults` （默認設置為`false` ）-此設置為`true` ，將假定更新 Apollo Cache 時的每個操作都是不可變的. 它還將`freezeResults`設置為`true` ，因此任何嘗試`freezeResults` Apollo Cache 的嘗試都會在開發環境中引發控制臺警告. 在將此選項設置為`true`之前，請確保在緩存更新操作中遵循不變性模式.
## GraphQL Queries[](#graphql-queries "Permalink")
為了在運行時保存查詢編譯，webpack 可以直接導入`.graphql`文件. 這使 webpack 可以在編譯時對查詢進行預處理，而不是由客戶端進行查詢的編譯.
為了將查詢與突變和片段區分開來，建議使用以下命名約定：
* `all_users.query.graphql`用于查詢；
* `add_user.mutation.graphql`進行突變；
* 片段的`basic_user.fragment.graphql` .
### Fragments[](#fragments "Permalink")
[片段](https://s0graphql0org.icopy.site/learn/queries/)是使復雜的 GraphQL 查詢更具可讀性和可重用性的一種方式. 這是 GraphQL 片段的示例：
```
fragment DesignListItem on Design {
id
image
event
filename
notesCount
}
```
片段可以存儲在單獨的文件中，可以導入并用于查詢，突變或其他片段.
```
#import "./design_list.fragment.graphql"
#import "./diff_refs.fragment.graphql"
fragment DesignItem on Design {
...DesignListItem
fullPath
diffRefs {
...DesignDiffRefs
}
}
```
有關片段的更多信息： [GraphQL Docs](https://s0graphql0org.icopy.site/learn/queries/)
## Usage in Vue[](#usage-in-vue "Permalink")
要使用 Vue Apollo，請導入[Vue Apollo](https://github.com/vuejs/vue-apollo)插件以及默認客戶端. 這應該在安裝 Vue 應用程序的同一時間創建.
```
import Vue from 'vue';
import VueApollo from 'vue-apollo';
import createDefaultClient from '~/lib/graphql';
Vue.use(VueApollo);
const apolloProvider = new VueApollo({
defaultClient: createDefaultClient(),
});
new Vue({
...,
apolloProvider,
...
});
```
在[Vue Apollo 文檔中](https://vue-apollo.netlify.app/guide/)閱讀有關[Vue Apollo 的](https://github.com/vuejs/vue-apollo)更多信息.
### Local state with Apollo[](#local-state-with-apollo "Permalink")
創建默認客戶端時，可以通過傳入 resolvers 對象來使用 Apollo 管理應用程序狀態. 設置默認客戶端后，可以通過寫入緩存來設置默認狀態.
```
import Vue from 'vue';
import VueApollo from 'vue-apollo';
import createDefaultClient from '~/lib/graphql';
Vue.use(VueApollo);
const defaultClient = createDefaultClient({
resolvers: {}
});
defaultClient.cache.writeData({
data: {
user: {
name: 'John',
surname: 'Doe',
age: 30
},
},
});
const apolloProvider = new VueApollo({
defaultClient,
});
```
我們可以使用`@client` Apollo 指令查詢本地數據：
```
// user.query.graphql
query User {
user @client {
name
surname
age
}
}
```
除了創建本地數據，我們還可以使用`@client`字段擴展現有的 GraphQL 類型. 當我們需要為尚未添加到 GraphQL API 中的字段模擬 API 響應時，這非常有用.
#### Mocking API response with local Apollo cache[](#mocking-api-response-with-local-apollo-cache "Permalink")
當我們需要在本地模擬某些 GraphQL API 響應，查詢或變異時（例如，當它們仍未添加到我們的實際 API 中時），使用本地 Apollo 緩存非常方便.
例如，我們在查詢中使用了有關`DesignVersion`的[片段](#fragments) ：
```
fragment VersionListItem on DesignVersion {
id
sha
}
```
我們還需要獲取版本作者和'created at'屬性，以在版本下拉列表中顯示它們，但這些更改仍未在我們的 API 中實現. 我們可以更改現有片段，以針對這些新字段獲得模擬的響應：
```
fragment VersionListItem on DesignVersion {
id
sha
author @client {
avatarUrl
name
}
createdAt @client
}
```
現在，Apollo 將嘗試為每個標有`@client`指令的字段查找*解析器* . 讓我們為`DesignVersion`類型創建一個解析器（為什么要使用`DesignVersion` ？，因為我們的片段是在這種類型上創建的）.
```
// resolvers.js
const resolvers = {
DesignVersion: {
author: () => ({
avatarUrl:
'https://www.gravatar.com/avatar/e64c7d89f26bd1972efa854d13d7dd61?s=80&d=identicon',
name: 'Administrator',
__typename: 'User',
}),
createdAt: () => '2019-11-13T16:08:11Z',
},
};
export default resolvers;
```
我們需要將解析器對象傳遞給我們現有的 Apollo Client：
```
// graphql.js
import createDefaultClient from '~/lib/graphql';
import resolvers from './graphql/resolvers';
const defaultClient = createDefaultClient(
{},
resolvers,
);
```
現在，每次嘗試獲取版本時，我們的客戶端都會從遠程 API 端點獲取`id`和`sha` ，并將我們的硬編碼值分配給`author`和`createdAt`版本屬性. 有了這些數據，前端開發人員就可以在 UI 部件上工作，而不會被后端阻塞. 將實際響應添加到 API 后，可以快速刪除自定義本地解析器，并且對查詢/片段的唯一更改是`@client`指令刪除.
在[Vue Apollo 文檔中](https://vue-apollo.netlify.app/guide/local-state.html#local-state)閱讀有關使用 Apollo 進行本地狀態管理的更多信息.
### Using with Vuex[](#using-with-vuex "Permalink")
When Apollo Client is used within Vuex and fetched data is stored in the Vuex store, there is no need in keeping Apollo Client cache enabled. Otherwise we would have data from the API stored in two places - Vuex store and Apollo Client cache. More to say, with Apollo’s default settings, a subsequent fetch from the GraphQL API could result in fetching data from Apollo cache (in the case where we have the same query and variables). To prevent this behavior, we need to disable Apollo Client cache passing a valid `fetchPolicy` option to its constructor:
```
import fetchPolicies from '~/graphql_shared/fetch_policy_constants';
export const gqClient = createGqClient(
{},
{
fetchPolicy: fetchPolicies.NO_CACHE,
},
);
```
### Feature flags in queries[](#feature-flags-in-queries "Permalink")
有時在 GraphQL 查詢中的功能標志后面放置一個實體可能會很有用. 例如，當處理后端已經合并但前端沒有合并的功能時，您可能希望將 GraphQL 實體放在功能標記后面，以允許創建和合并較小的合并請求.
為此， `if`語句通過，我們可以使用`@include`指令排除實體.
```
query getAuthorData($authorNameEnabled: Boolean = false) { username name @include(if: $authorNameEnabled) }
```
然后，在對查詢的 Vue（或 JavaScript）調用中，我們可以傳遞功能標記. 此功能標志將需要已經正確設置. 有關正確方法，請參閱[功能部件標志文檔](../feature_flags/development.html) .
```
export default {
apollo: {
user: {
query: QUERY_IMPORT,
variables() {
return {
authorNameEnabled: gon?.features?.authorNameEnabled,
};
},
}
},
};
```
### Manually triggering queries[](#manually-triggering-queries "Permalink")
創建組件時，將自動對組件的`apollo`屬性進行查詢. 某些組件反而希望按需發出網絡請求，例如，帶有延遲加載項的下拉列表.
有兩種方法可以做到這一點：
1. Use the `skip` property
```
export default {
apollo: {
user: {
query: QUERY_IMPORT,
skip() {
// only make the query when dropdown is open
return !this.isOpen;
},
}
},
};
```
1. Using `addSmartQuery`
您可以在您的方法中手動創建智能查詢.
```
handleClick() {
this.$apollo.addSmartQuery('user', {
// this takes the same values as you'd have in the `apollo` section
query: QUERY_IMPORT,
}),
};
```
### Working with pagination[](#working-with-pagination "Permalink")
GitLab 的 GraphQL API 對連接類型使用[中繼樣式的游標分頁](https://www.apollographql.com/docs/react/data/pagination/#cursor-based) . 這意味著使用"游標"來跟蹤應從中提取下一項的數據集中的位置. [GraphQL Ruby Connection Concepts](https://graphql-ruby.org/pagination/connection_concepts.html)是對連接的良好概述和介紹.
每個連接類型（例如`DesignConnection`和`DiscussionConnection` ）都有一個字段`pageInfo` ，其中包含分頁所需的信息：
```
pageInfo {
endCursor
hasNextPage
hasPreviousPage
startCursor
}
```
Here:
* `startCursor`和`endCursor`顯示第一項和最后一項的光標.
* `hasPreviousPage`和`hasNextPage`允許我們檢查當前頁面之前或之后是否還有更多頁面可用.
當我們以連接類型獲取數據時，我們可以`before`參數的`after`或`before`傳遞游標，以指示分頁的起點或終點. 應該分別在它們的后跟`first`或`last`參數，以指示我們要在給定端點之后或之前獲取*多少個*項目.
例如，這里我們在光標之后獲取 10 個設計：
```
query {
project(fullPath: "root/my-project") {
id
issue(iid: "42") {
designCollection {
designs(atVersion: null, after: "Ihwffmde0i", first: 10) {
edges {
node {
id
}
}
}
}
}
}
}
```
#### Using `fetchMore` method in components[](#using-fetchmore-method-in-components "Permalink")
進行初始抓取時，我們通常希望從頭開始進行分頁. 在這種情況下，我們可以：
* 跳過傳遞光標.
* 將`null`明確傳遞給`after` .
提取數據后，我們應該保存一個`pageInfo`對象. 假設我們將其存儲到 Vue 組件`data` ：
```
data() {
return {
pageInfo: null,
}
},
apollo: {
designs: {
query: projectQuery,
variables() {
return {
// rest of design variables
...
first: 10,
};
},
result(res) {
this.pageInfo = res.data?.project?.issue?.designCollection?.designs?.pageInfo;
},
},
},
```
當我們想移至下一頁時，我們使用 Apollo `fetchMore`方法，在該方法中傳遞一個新的游標（以及可選的新變量）. 在`updateQuery`掛鉤中，我們必須在獲取下一頁之后返回要在 Apollo 緩存中看到的結果.
```
fetchNextPage() {
// as a first step, we're checking if we have more pages to move forward
if (this.pageInfo?.hasNextPage) {
this.$apollo.queries.designs.fetchMore({
variables: {
// rest of design variables
...
first: 10,
after: this.pageInfo?.endCursor,
},
updateQuery(previousResult, { fetchMoreResult }) {
// here we can implement the logic of adding new designs to fetched one (for example, if we use infinite scroll)
// or replacing old result with the new one if we use numbered pages
const newDesigns = fetchMoreResult.project.issue.designCollection.designs;
previousResult.project.issue.designCollection.designs.push(...newDesigns)
return previousResult;
},
});
}
}
```
請注意，我們不必再保存`pageInfo`了； `fetchMore`觸發查詢`result`掛鉤.
### Testing[](#testing "Permalink")
#### Mocking response as component data[](#mocking-response-as-component-data "Permalink")
使用[Vue 測試工具](https://vue-test-utils.vuejs.org/) ，可以輕松快速地測試獲取 GraphQL 查詢的組件. 最簡單的方法是使用`shallowMount` ，然后在組件上設置數據
```
it('tests apollo component', () => {
const vm = shallowMount(App);
vm.setData({
...mock data
});
});
```
#### Testing loading state[](#testing-loading-state "Permalink")
如果需要測試當 GraphQL API 的結果仍在加載時組件的呈現方式，我們可以將加載狀態模擬到相應的 Apollo 查詢/突變中：
```
function createComponent({
loading = false,
} = {}) {
const $apollo = {
queries: {
designs: {
loading,
},
};
wrapper = shallowMount(Index, {
sync: false,
mocks: { $apollo }
});
}
it('renders loading icon', () => {
createComponent({ loading: true });
expect(wrapper.element).toMatchSnapshot();
})
```
#### Testing Apollo components[](#testing-apollo-components "Permalink")
如果我們在組件中使用`ApolloQuery`或`ApolloMutation` ，為了測試其功能，我們需要先添加一個存根：
```
import { ApolloMutation } from 'vue-apollo';
function createComponent(props = {}) {
wrapper = shallowMount(MyComponent, {
sync: false,
propsData: {
...props,
},
stubs: {
ApolloMutation,
},
});
}
```
`ApolloMutation`組件通過作用域插槽公開了`mutate`方法. 如果要測試此方法，則需要將其添加到模擬中：
```
const mutate = jest.fn().mockResolvedValue();
const $apollo = {
mutate,
};
function createComponent(props = {}) {
wrapper = shallowMount(MyComponent, {
sync: false,
propsData: {
...props,
},
stubs: {
ApolloMutation,
},
mocks: {
$apollo:
}
});
}
```
然后我們可以檢查是否使用正確的變量調用了`mutate` ：
```
const mutationVariables = {
mutation: createNoteMutation,
update: expect.anything(),
variables: {
input: {
noteableId: 'noteable-id',
body: 'test',
discussionId: '0',
},
},
};
it('calls mutation on submitting form ', () => {
createComponent()
findReplyForm().vm.$emit('submitForm');
expect(mutate).toHaveBeenCalledWith(mutationVariables);
});
```
## Handling errors[](#handling-errors "Permalink")
目前，GitLab 的 GraphQL 突變具有兩種不同的錯誤模式： [頂級](#top-level-errors)和[數據錯誤](#errors-as-data) .
利用 GraphQL 突變時，我們必須考慮處理**這兩種錯誤模式，**以確保用戶在發生錯誤時能夠收到適當的反饋.
### Top-level errors[](#top-level-errors "Permalink")
這些錯誤位于 GraphQL 響應的"頂級". 這些是不可恢復的錯誤，包括參數錯誤和語法錯誤，因此不應直接呈現給用戶.
#### Handling top-level errors[](#handling-top-level-errors "Permalink")
Apollo 意識到頂級錯誤，因此我們能夠利用 Apollo 的各種錯誤處理機制來處理這些錯誤（例如，在調用[`mutate`](https://www.apollographql.com/docs/react/api/apollo-client/#ApolloClient.mutate)方法之后處理 Promise 拒絕，或處理從[`ApolloMutation`](https://apollo.vuejs.org/api/apollo-mutation.html#events)組件發出的`error`事件）.
由于這些錯誤不是針對用戶的，因此應在客戶端定義頂級錯誤的錯誤消息.
### Errors-as-data[](#errors-as-data "Permalink")
這些錯誤嵌套在 GraphQL 響應的`data`對象中. 這些是可恢復的錯誤，理想情況下，可以直接向用戶顯示.
#### Handling errors-as-data[](#handling-errors-as-data "Permalink")
首先，我們必須向我們的變異對象添加`errors` ：
```
mutation createNoteMutation($input: String!) {
createNoteMutation(input: $input) {
note {
id
+ errors
}
}
```
現在，當我們提交此突變并發生錯誤時，響應中將包含`errors`供我們處理：
```
{
data: {
mutationName: {
errors: ["Sorry, we were not able to update the note."]
}
}
}
```
處理數據錯誤時，請根據您的最佳判斷來確定是將錯誤消息顯示在響應中，還是將另一條客戶端定義的消息顯示給用戶.
## Usage outside of Vue[](#usage-outside-of-vue "Permalink")
通過直接導入默認客戶端并將其與查詢一起使用，還可以在 Vue 之外使用 GraphQL.
```
import createDefaultClient from '~/lib/graphql';
import query from './query.graphql';
const defaultClient = createDefaultClient();
defaultClient.query({ query })
.then(result => console.log(result));
```
[使用 Vuex 時](#Using-with-Vuex) ，在以下情況下禁用緩存：
* 數據正在其他地方緩存
* 如果數據正在其他地方緩存，或者對于給定的用例完全不需要，則用例不需要緩存.
```
import createDefaultClient from '~/lib/graphql';
import fetchPolicies from '~/graphql_shared/fetch_policy_constants';
const defaultClient = createDefaultClient(
{},
{
fetchPolicy: fetchPolicies.NO_CACHE,
},
);
```
- GitLab Docs
- Installation
- Requirements
- GitLab cloud native Helm Chart
- Install GitLab with Docker
- Installation from source
- Install GitLab on Microsoft Azure
- Installing GitLab on Google Cloud Platform
- Installing GitLab on Amazon Web Services (AWS)
- Analytics
- Code Review Analytics
- Productivity Analytics
- Value Stream Analytics
- Kubernetes clusters
- Adding and removing Kubernetes clusters
- Adding EKS clusters
- Adding GKE clusters
- Group-level Kubernetes clusters
- Instance-level Kubernetes clusters
- Canary Deployments
- Cluster Environments
- Deploy Boards
- GitLab Managed Apps
- Crossplane configuration
- Cluster management project (alpha)
- Kubernetes Logs
- Runbooks
- Serverless
- Deploying AWS Lambda function using GitLab CI/CD
- Securing your deployed applications
- Groups
- Contribution Analytics
- Custom group-level project templates
- Epics
- Manage epics
- Group Import/Export
- Insights
- Issues Analytics
- Iterations
- Public access
- SAML SSO for GitLab.com groups
- SCIM provisioning using SAML SSO for GitLab.com groups
- Subgroups
- Roadmap
- Projects
- GitLab Secure
- Security Configuration
- Container Scanning
- Dependency Scanning
- Dependency List
- Static Application Security Testing (SAST)
- Secret Detection
- Dynamic Application Security Testing (DAST)
- GitLab Security Dashboard
- Offline environments
- Standalone Vulnerability pages
- Security scanner integration
- Badges
- Bulk editing issues and merge requests at the project level
- Code Owners
- Compliance
- License Compliance
- Compliance Dashboard
- Create a project
- Description templates
- Deploy Keys
- Deploy Tokens
- File finder
- Project integrations
- Integrations
- Atlassian Bamboo CI Service
- Bugzilla Service
- Custom Issue Tracker service
- Discord Notifications service
- Enabling emails on push
- GitHub project integration
- Hangouts Chat service
- Atlassian HipChat
- Irker IRC Gateway
- GitLab Jira integration
- Mattermost Notifications Service
- Mattermost slash commands
- Microsoft Teams service
- Mock CI Service
- Prometheus integration
- Redmine Service
- Slack Notifications Service
- Slack slash commands
- GitLab Slack application
- Webhooks
- YouTrack Service
- Insights
- Issues
- Crosslinking Issues
- Design Management
- Confidential issues
- Due dates
- Issue Boards
- Issue Data and Actions
- Labels
- Managing issues
- Milestones
- Multiple Assignees for Issues
- Related issues
- Service Desk
- Sorting and ordering issue lists
- Issue weight
- Associate a Zoom meeting with an issue
- Merge requests
- Allow collaboration on merge requests across forks
- Merge Request Approvals
- Browser Performance Testing
- How to create a merge request
- Cherry-pick changes
- Code Quality
- Load Performance Testing
- Merge Request dependencies
- Fast-forward merge requests
- Merge when pipeline succeeds
- Merge request conflict resolution
- Reverting changes
- Reviewing and managing merge requests
- Squash and merge
- Merge requests versions
- Draft merge requests
- Members of a project
- Migrating projects to a GitLab instance
- Import your project from Bitbucket Cloud to GitLab
- Import your project from Bitbucket Server to GitLab
- Migrating from ClearCase
- Migrating from CVS
- Import your project from FogBugz to GitLab
- Gemnasium
- Import your project from GitHub to GitLab
- Project importing from GitLab.com to your private GitLab instance
- Import your project from Gitea to GitLab
- Import your Jira project issues to GitLab
- Migrating from Perforce Helix
- Import Phabricator tasks into a GitLab project
- Import multiple repositories by uploading a manifest file
- Import project from repo by URL
- Migrating from SVN to GitLab
- Migrating from TFVC to Git
- Push Options
- Releases
- Repository
- Branches
- Git Attributes
- File Locking
- Git file blame
- Git file history
- Repository mirroring
- Protected branches
- Protected tags
- Push Rules
- Reduce repository size
- Signing commits with GPG
- Syntax Highlighting
- GitLab Web Editor
- Web IDE
- Requirements Management
- Project settings
- Project import/export
- Project access tokens (Alpha)
- Share Projects with other Groups
- Snippets
- Static Site Editor
- Wiki
- Project operations
- Monitor metrics for your CI/CD environment
- Set up alerts for Prometheus metrics
- Embedding metric charts within GitLab-flavored Markdown
- Embedding Grafana charts
- Using the Metrics Dashboard
- Dashboard YAML properties
- Metrics dashboard settings
- Panel types for dashboards
- Using Variables
- Templating variables for metrics dashboards
- Prometheus Metrics library
- Monitoring AWS Resources
- Monitoring HAProxy
- Monitoring Kubernetes
- Monitoring NGINX
- Monitoring NGINX Ingress Controller
- Monitoring NGINX Ingress Controller with VTS metrics
- Alert Management
- Error Tracking
- Tracing
- Incident Management
- GitLab Status Page
- Feature Flags
- GitLab CI/CD
- GitLab CI/CD pipeline configuration reference
- GitLab CI/CD include examples
- Introduction to CI/CD with GitLab
- Getting started with GitLab CI/CD
- How to enable or disable GitLab CI/CD
- Using SSH keys with GitLab CI/CD
- Migrating from CircleCI
- Migrating from Jenkins
- Auto DevOps
- Getting started with Auto DevOps
- Requirements for Auto DevOps
- Customizing Auto DevOps
- Stages of Auto DevOps
- Upgrading PostgreSQL for Auto DevOps
- Cache dependencies in GitLab CI/CD
- GitLab ChatOps
- Cloud deployment
- Docker integration
- Building Docker images with GitLab CI/CD
- Using Docker images
- Building images with kaniko and GitLab CI/CD
- GitLab CI/CD environment variables
- Predefined environment variables reference
- Where variables can be used
- Deprecated GitLab CI/CD variables
- Environments and deployments
- Protected Environments
- GitLab CI/CD Examples
- Test a Clojure application with GitLab CI/CD
- Using Dpl as deployment tool
- Testing a Phoenix application with GitLab CI/CD
- End-to-end testing with GitLab CI/CD and WebdriverIO
- DevOps and Game Dev with GitLab CI/CD
- Deploy a Spring Boot application to Cloud Foundry with GitLab CI/CD
- How to deploy Maven projects to Artifactory with GitLab CI/CD
- Testing PHP projects
- Running Composer and NPM scripts with deployment via SCP in GitLab CI/CD
- Test and deploy Laravel applications with GitLab CI/CD and Envoy
- Test and deploy a Python application with GitLab CI/CD
- Test and deploy a Ruby application with GitLab CI/CD
- Test and deploy a Scala application to Heroku
- GitLab CI/CD for external repositories
- Using GitLab CI/CD with a Bitbucket Cloud repository
- Using GitLab CI/CD with a GitHub repository
- GitLab Pages
- GitLab Pages
- GitLab Pages domain names, URLs, and baseurls
- Create a GitLab Pages website from scratch
- Custom domains and SSL/TLS Certificates
- GitLab Pages integration with Let's Encrypt
- GitLab Pages Access Control
- Exploring GitLab Pages
- Incremental Rollouts with GitLab CI/CD
- Interactive Web Terminals
- Optimizing GitLab for large repositories
- Metrics Reports
- CI/CD pipelines
- Pipeline Architecture
- Directed Acyclic Graph
- Multi-project pipelines
- Parent-child pipelines
- Pipelines for Merge Requests
- Pipelines for Merged Results
- Merge Trains
- Job artifacts
- Pipeline schedules
- Pipeline settings
- Triggering pipelines through the API
- Review Apps
- Configuring GitLab Runners
- GitLab CI services examples
- Using MySQL
- Using PostgreSQL
- Using Redis
- Troubleshooting CI/CD
- GitLab Package Registry
- GitLab Container Registry
- Dependency Proxy
- GitLab Composer Repository
- GitLab Conan Repository
- GitLab Maven Repository
- GitLab NPM Registry
- GitLab NuGet Repository
- GitLab PyPi Repository
- API Docs
- API resources
- .gitignore API
- GitLab CI YMLs API
- Group and project access requests API
- Appearance API
- Applications API
- Audit Events API
- Avatar API
- Award Emoji API
- Project badges API
- Group badges API
- Branches API
- Broadcast Messages API
- Project clusters API
- Group clusters API
- Instance clusters API
- Commits API
- Container Registry API
- Custom Attributes API
- Dashboard annotations API
- Dependencies API
- Deploy Keys API
- Deployments API
- Discussions API
- Dockerfiles API
- Environments API
- Epics API
- Events
- Feature Flags API
- Feature flag user lists API
- Freeze Periods API
- Geo Nodes API
- Group Activity Analytics API
- Groups API
- Import API
- Issue Boards API
- Group Issue Boards API
- Issues API
- Epic Issues API
- Issues Statistics API
- Jobs API
- Keys API
- Labels API
- Group Labels API
- License
- Licenses API
- Issue links API
- Epic Links API
- Managed Licenses API
- Markdown API
- Group and project members API
- Merge request approvals API
- Merge requests API
- Project milestones API
- Group milestones API
- Namespaces API
- Notes API
- Notification settings API
- Packages API
- Pages domains API
- Pipeline schedules API
- Pipeline triggers API
- Pipelines API
- Project Aliases API
- Project import/export API
- Project repository storage moves API
- Project statistics API
- Project templates API
- Projects API
- Protected branches API
- Protected tags API
- Releases API
- Release links API
- Repositories API
- Repository files API
- Repository submodules API
- Resource label events API
- Resource milestone events API
- Resource weight events API
- Runners API
- SCIM API
- Search API
- Services API
- Application settings API
- Sidekiq Metrics API
- Snippets API
- Project snippets
- Application statistics API
- Suggest Changes API
- System hooks API
- Tags API
- Todos API
- Users API
- Project-level Variables API
- Group-level Variables API
- Version API
- Vulnerabilities API
- Vulnerability Findings API
- Wikis API
- GraphQL API
- Getting started with GitLab GraphQL API
- GraphQL API Resources
- API V3 to API V4
- Validate the .gitlab-ci.yml (API)
- User Docs
- Abuse reports
- User account
- Active sessions
- Deleting a User account
- Permissions
- Personal access tokens
- Profile preferences
- Threads
- GitLab and SSH keys
- GitLab integrations
- Git
- GitLab.com settings
- Infrastructure as code with Terraform and GitLab
- GitLab keyboard shortcuts
- GitLab Markdown
- AsciiDoc
- GitLab Notification Emails
- GitLab Quick Actions
- Autocomplete characters
- Reserved project and group names
- Search through GitLab
- Advanced Global Search
- Advanced Syntax Search
- Time Tracking
- GitLab To-Do List
- Administrator Docs
- Reference architectures
- Reference architecture: up to 1,000 users
- Reference architecture: up to 2,000 users
- Reference architecture: up to 3,000 users
- Reference architecture: up to 5,000 users
- Reference architecture: up to 10,000 users
- Reference architecture: up to 25,000 users
- Reference architecture: up to 50,000 users
- Troubleshooting a reference architecture set up
- Working with the bundled Consul service
- Configuring PostgreSQL for scaling
- Configuring GitLab application (Rails)
- Load Balancer for multi-node GitLab
- Configuring a Monitoring node for Scaling and High Availability
- NFS
- Working with the bundled PgBouncer service
- Configuring Redis for scaling
- Configuring Sidekiq
- Admin Area settings
- Continuous Integration and Deployment Admin settings
- Custom instance-level project templates
- Diff limits administration
- Enable and disable GitLab features deployed behind feature flags
- Geo nodes Admin Area
- GitLab Pages administration
- Health Check
- Job logs
- Labels administration
- Log system
- PlantUML & GitLab
- Repository checks
- Repository storage paths
- Repository storage types
- Account and limit settings
- Service templates
- System hooks
- Changing your time zone
- Uploads administration
- Abuse reports
- Activating and deactivating users
- Audit Events
- Blocking and unblocking users
- Broadcast Messages
- Elasticsearch integration
- Gitaly
- Gitaly Cluster
- Gitaly reference
- Monitoring GitLab
- Monitoring GitLab with Prometheus
- Performance Bar
- Usage statistics
- Object Storage
- Performing Operations in GitLab
- Cleaning up stale Redis sessions
- Fast lookup of authorized SSH keys in the database
- Filesystem Performance Benchmarking
- Moving repositories managed by GitLab
- Run multiple Sidekiq processes
- Sidekiq MemoryKiller
- Switching to Puma
- Understanding Unicorn and unicorn-worker-killer
- User lookup via OpenSSH's AuthorizedPrincipalsCommand
- GitLab Package Registry administration
- GitLab Container Registry administration
- Replication (Geo)
- Geo database replication
- Geo with external PostgreSQL instances
- Geo configuration
- Using a Geo Server
- Updating the Geo nodes
- Geo with Object storage
- Docker Registry for a secondary node
- Geo for multiple nodes
- Geo security review (Q&A)
- Location-aware Git remote URL with AWS Route53
- Tuning Geo
- Removing secondary Geo nodes
- Geo data types support
- Geo Frequently Asked Questions
- Geo Troubleshooting
- Geo validation tests
- Disaster Recovery (Geo)
- Disaster recovery for planned failover
- Bring a demoted primary node back online
- Automatic background verification
- Rake tasks
- Back up and restore GitLab
- Clean up
- Namespaces
- Maintenance Rake tasks
- Geo Rake Tasks
- GitHub import
- Import bare repositories
- Integrity check Rake task
- LDAP Rake tasks
- Listing repository directories
- Praefect Rake tasks
- Project import/export administration
- Repository storage Rake tasks
- Generate sample Prometheus data
- Uploads migrate Rake tasks
- Uploads sanitize Rake tasks
- User management
- Webhooks administration
- X.509 signatures
- Server hooks
- Static objects external storage
- Updating GitLab
- GitLab release and maintenance policy
- Security
- Password Storage
- Custom password length limits
- Restrict allowed SSH key technologies and minimum length
- Rate limits
- Webhooks and insecure internal web services
- Information exclusivity
- How to reset your root password
- How to unlock a locked user from the command line
- User File Uploads
- How we manage the TLS protocol CRIME vulnerability
- User email confirmation at sign-up
- Security of running jobs
- Proxying assets
- CI/CD Environment Variables
- Contributor and Development Docs
- Contribute to GitLab
- Community members & roles
- Implement design & UI elements
- Issues workflow
- Merge requests workflow
- Code Review Guidelines
- Style guides
- GitLab Architecture Overview
- CI/CD development documentation
- Database guides
- Database Review Guidelines
- Database Review Guidelines
- Migration Style Guide
- What requires downtime?
- Understanding EXPLAIN plans
- Rake tasks for developers
- Mass inserting Rails models
- GitLab Documentation guidelines
- Documentation Style Guide
- Documentation structure and template
- Documentation process
- Documentation site architecture
- Global navigation
- GitLab Docs monthly release process
- Telemetry Guide
- Usage Ping Guide
- Snowplow Guide
- Experiment Guide
- Feature flags in development of GitLab
- Feature flags process
- Developing with feature flags
- Feature flag controls
- Document features deployed behind feature flags
- Frontend Development Guidelines
- Accessibility & Readability
- Ajax
- Architecture
- Axios
- Design Patterns
- Frontend Development Process
- DropLab
- Emojis
- Filter
- Frontend FAQ
- GraphQL
- Icons and SVG Illustrations
- InputSetter
- Performance
- Principles
- Security
- Tooling
- Vuex
- Vue
- Geo (development)
- Geo self-service framework (alpha)
- Gitaly developers guide
- GitLab development style guides
- API style guide
- Go standards and style guidelines
- GraphQL API style guide
- Guidelines for shell commands in the GitLab codebase
- HTML style guide
- JavaScript style guide
- Migration Style Guide
- Newlines style guide
- Python Development Guidelines
- SCSS style guide
- Shell scripting standards and style guidelines
- Sidekiq debugging
- Sidekiq Style Guide
- SQL Query Guidelines
- Vue.js style guide
- Instrumenting Ruby code
- Testing standards and style guidelines
- Flaky tests
- Frontend testing standards and style guidelines
- GitLab tests in the Continuous Integration (CI) context
- Review Apps
- Smoke Tests
- Testing best practices
- Testing levels
- Testing Rails migrations at GitLab
- Testing Rake tasks
- End-to-end Testing
- Beginner's guide to writing end-to-end tests
- End-to-end testing Best Practices
- Dynamic Element Validation
- Flows in GitLab QA
- Page objects in GitLab QA
- Resource class in GitLab QA
- Style guide for writing end-to-end tests
- Testing with feature flags
- Translate GitLab to your language
- Internationalization for GitLab
- Translating GitLab
- Proofread Translations
- Merging translations from CrowdIn
- Value Stream Analytics development guide
- GitLab subscription
- Activate GitLab EE with a license