Read about our upcoming Code of Conduct on this issue

environments.md 29.5 KB
Newer Older
Marcia Ramos's avatar
Marcia Ramos committed
1
2
3
4
---
type: reference
---

5
# Environments and deployments
6

7
> Introduced in GitLab 8.9.
8

9
10
Environments allow control of the continuous deployment of your software,
all within GitLab.
11

12
13
14
15
16
17
18
19
20
21
22
## Introduction

There are many stages required in the software development process before the software is ready
for public consumption.

For example:

1. Develop your code.
1. Test your code.
1. Deploy your code into a testing or staging environment before you release it to the public.

23
This helps find bugs in your software, and also in the deployment process as well.
24
25

GitLab CI/CD is capable of not only testing or building your projects, but also
26
deploying them in your infrastructure, with the added benefit of giving you a
27
way to track your deployments. In other words, you will always know what is
28
currently being deployed or has been deployed on your servers.
29

30
It's important to know that:
31

32
33
34
- Environments are like tags for your CI jobs, describing where code gets deployed.
- Deployments are created when [jobs](yaml/README.md#introduction) deploy versions of code to environments,
  so every environment can have one or more deployments.
35

36
37
GitLab:

38
- Provides a full history of your deployments for each environment.
39
40
41
42
- Keeps track of your deployments, so you always know what is currently being deployed on your
  servers.

If you have a deployment service such as [Kubernetes](../user/project/clusters/index.md)
43
associated with your project, you can use it to assist with your deployments, and
44
can even access a [web terminal](#web-terminals) for your environment from within GitLab!
45

46
47
48
49
50
51
## Configuring environments

Configuring environments involves:

1. Understanding how [pipelines](pipelines.md) work.
1. Defining environments in your project's [`.gitlab-ci.yml`](yaml/README.md) file.
52
1. Creating a job configured to deploy your application. For example, a deploy job configured with [`environment`](yaml/README.md#environment) to deploy your application to a [Kubernetes cluster](../user/project/clusters/index.md).
53

54
55
The rest of this section illustrates how to configure environments and deployments using
an example scenario. It assumes you have already:
56

57
58
- Created a [project](../gitlab-basics/create-project.md) in GitLab.
- Set up [a Runner](runners/README.md).
59

60
In the scenario:
61

62
63
64
65
66
67
- We are developing an application.
- We want to run tests and build our app on all branches.
- Our default branch is `master`.
- We deploy the app only when a pipeline on `master` branch is run.

### Defining environments
68

69
Let's consider the following `.gitlab-ci.yml` example:
70

71
72
73
74
75
```yaml
stages:
  - test
  - build
  - deploy
76

77
78
79
test:
  stage: test
  script: echo "Running tests"
80

81
82
83
build:
  stage: build
  script: echo "Building the app"
84

85
86
87
deploy_staging:
  stage: deploy
  script:
88
    - echo "Deploy to staging server"
89
  environment:
90
91
    name: staging
    url: https://staging.example.com
92
93
94
  only:
  - master
```
95

Evan Read's avatar
Evan Read committed
96
We have defined three [stages](yaml/README.md#stages):
97

98
99
100
- `test`
- `build`
- `deploy`
101

102
103
The jobs assigned to these stages will run in this order. If any job fails, then
the pipeline fails and jobs that are assigned to the next stage won't run.
104
105
106
107
108
109
110

In our case:

- The `test` job will run first.
- Then the `build` job.
- Lastly the `deploy_staging` job.

111
With this configuration, we:
112

113
114
- Check that the tests pass.
- Ensure that our app is able to be built successfully.
115
- Lastly we deploy to the staging server.
116

117
NOTE: **Note:**
118
119
120
121
122
123
124
125
The `environment` keyword defines where the app is deployed.
The environment `name` and `url` is exposed in various places
within GitLab. Each time a job that has an environment specified
succeeds, a deployment is recorded, along with the Git SHA and environment name.

CAUTION: **Caution**:
Some characters are not allowed in environment names. Use only letters,
numbers, spaces, and `-`, `_`, `/`, `{`, `}`, or `.`. Also, it must not start nor end with `/`.
126

127
128
129
130
131
132
133
134
135
136
In summary, with the above `.gitlab-ci.yml` we have achieved the following:

- All branches will run the `test` and `build` jobs.
- The `deploy_staging` job will run [only](yaml/README.md#onlyexcept-basic) on the `master`
  branch, which means all merge requests that are created from branches don't
  get deployed to the staging server.
- When a merge request is merged, all jobs will run and the `deploy_staging`
  job will deploy our code to a staging server while the deployment
  will be recorded in an environment named `staging`.

137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
#### Environment variables and Runner

Starting with GitLab 8.15, the environment name is exposed to the Runner in
two forms:

- `$CI_ENVIRONMENT_NAME`. The name given in `.gitlab-ci.yml` (with any variables
  expanded).
- `$CI_ENVIRONMENT_SLUG`. A "cleaned-up" version of the name, suitable for use in URLs,
  DNS, etc.

If you change the name of an existing environment, the:

- `$CI_ENVIRONMENT_NAME` variable will be updated with the new environment name.
- `$CI_ENVIRONMENT_SLUG` variable will remain unchanged to prevent unintended side
  effects.

Starting with GitLab 9.3, the environment URL is exposed to the Runner via
`$CI_ENVIRONMENT_URL`. The URL is expanded from either:

- `.gitlab-ci.yml`.
- The external URL from the environment if not defined in `.gitlab-ci.yml`.
158

159
### Configuring manual deployments
160

161
162
Adding `when: manual` to an automatically executed job's configuration converts it to
a job requiring manual action.
163

164
165
166
To expand on the [previous example](#defining-environments), the following includes
another job that deploys our app to a production server and is
tracked by a `production` environment.
167

168
The `.gitlab-ci.yml` file for this is as follows:
169

170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
```yaml
stages:
  - test
  - build
  - deploy

test:
  stage: test
  script: echo "Running tests"

build:
  stage: build
  script: echo "Building the app"

deploy_staging:
  stage: deploy
  script:
    - echo "Deploy to staging server"
  environment:
    name: staging
    url: https://staging.example.com
  only:
  - master

deploy_prod:
  stage: deploy
  script:
    - echo "Deploy to production server"
  environment:
    name: production
    url: https://example.com
  when: manual
  only:
  - master
```

206
207
The `when: manual` action:

208
- Exposes a "play" button in GitLab's UI for that job.
209
- Means the `deploy_prod` job will only be triggered when the "play" button is clicked.
210

211
You can find the "play" button in the pipelines, environments, deployments, and jobs views.
212

213
214
215
216
217
218
219
220
| View            | Screenshot                                                                     |
|:----------------|:-------------------------------------------------------------------------------|
| Pipelines       | ![Pipelines manual action](img/environments_manual_action_pipelines.png)       |
| Single pipeline | ![Pipelines manual action](img/environments_manual_action_single_pipeline.png) |
| Environments    | ![Environments manual action](img/environments_manual_action_environments.png) |
| Deployments     | ![Deployments manual action](img/environments_manual_action_deployments.png)   |
| Jobs            | ![Builds manual action](img/environments_manual_action_jobs.png)               |

221
222
Clicking on the play button in any view will trigger the `deploy_prod` job, and the
deployment will be recorded as a new environment named `production`.
223

224
225
NOTE: **Note:**
If your environment's name is `production` (all lowercase),
226
it will get recorded in [Value Stream Analytics](../user/project/cycle_analytics.md).
227

228
### Configuring dynamic environments
229

230
Regular environments are good when deploying to "stable" environments like staging or production.
231

232
233
However, for environments for branches other than `master`, dynamic environments
can be used. Dynamic environments make it possible to create environments on the fly by
234
235
declaring their names dynamically in `.gitlab-ci.yml`.

236
Dynamic environments are a fundamental part of [Review apps](review_apps/index.md).
237

238
239
240
241
242
### Configuring incremental rollouts

Learn how to release production changes to only a portion of your Kubernetes pods with
[incremental rollouts](environments/incremental_rollouts.md).

243
244
245
246
247
248
#### Allowed variables

The `name` and `url` parameters for dynamic environments can use most available CI/CD variables,
including:

- [Predefined environment variables](variables/README.md#predefined-environment-variables)
249
- [Project and group variables](variables/README.md#gitlab-cicd-environment-variables)
250
251
252
253
254
255
256
257
258
259
260
261
- [`.gitlab-ci.yml` variables](yaml/README.md#variables)

However, you cannot use variables defined:

- Under `script`.
- On the Runner's side.

There are also other variables that are unsupported in the context of `environment:name`.
For more information, see [Where variables can be used](variables/where_variables_can_be_used.md).

#### Example configuration

262
GitLab Runner exposes various [environment variables](variables/README.md) when a job runs, so
263
264
you can use them as environment names.

265
In the following example, the job will deploy to all branches except `master`:
266

267
268
269
270
271
272
```yaml
deploy_review:
  stage: deploy
  script:
    - echo "Deploy a review app"
  environment:
273
    name: review/$CI_COMMIT_REF_NAME
274
    url: https://$CI_ENVIRONMENT_SLUG.example.com
275
276
277
278
  only:
    - branches
  except:
    - master
279
```
280

281
282
283
284
285
In this example:

- The job's name is `deploy_review` and it runs on the `deploy` stage.
- We set the `environment` with the `environment:name` as `review/$CI_COMMIT_REF_NAME`.
  Since the [environment name](yaml/README.md#environmentname) can contain slashes (`/`), we can
286
287
288
  use this pattern to distinguish between dynamic and regular environments.
- We tell the job to run [`only`](yaml/README.md#onlyexcept-basic) on branches,
  [`except`](yaml/README.md#onlyexcept-basic) `master`.
289
290
291
292

For the value of:

- `environment:name`, the first part is `review`, followed by a `/` and then `$CI_COMMIT_REF_NAME`,
293
294
295
  which receives the value of the branch name.
- `environment:url`, we want a specific and distinct URL for each branch. `$CI_COMMIT_REF_NAME`
  may contain a `/` or other characters that would be invalid in a domain name or URL,
296
  so we use `$CI_ENVIRONMENT_SLUG` to guarantee that we get a valid URL.
297
298
299
300
301

  For example, given a `$CI_COMMIT_REF_NAME` of `100-Do-The-Thing`, the URL will be something
  like `https://100-do-the-4f99a2.example.com`. Again, the way you set up
  the web server to serve these requests is based on your setup.

302
  We have used `$CI_ENVIRONMENT_SLUG` here because it is guaranteed to be unique. If
303
  you're using a workflow like [GitLab Flow](../topics/gitlab_flow.md), collisions
304
  are unlikely and you may prefer environment names to be more closely based on the
305
306
  branch name. In that case, you could use `$CI_COMMIT_REF_NAME` in `environment:url` in
  the example above: `https://$CI_COMMIT_REF_NAME.example.com`, which would give a URL
307
  of `https://100-do-the-thing.example.com`.
308
309

NOTE: **Note:**
310
311
312
You are not required to use the same prefix or only slashes (`/`) in the dynamic environments'
names. However, using this format will enable the [grouping similar environments](#grouping-similar-environments)
feature.
313

314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
### Configuring Kubernetes deployments

> [Introduced](https://gitlab.com/gitlab-org/gitlab/issues/27630) in GitLab 12.6.

If you are deploying to a [Kubernetes cluster](../user/project/clusters/index.md)
associated with your project, you can configure these deployments from your
`gitlab-ci.yml` file.

The following configuration options are supported:

- [`namespace`](https://kubernetes.io/docs/concepts/overview/working-with-objects/namespaces/)

In the following example, the job will deploy your application to the
`production` Kubernetes namespace.

```yaml
deploy:
  stage: deploy
  script:
    - echo "Deploy to production server"
  environment:
    name: production
    url: https://example.com
    kubernetes:
      namespace: production
  only:
  - master
```

NOTE: **Note:**
Kubernetes configuration is not supported for Kubernetes clusters
that are [managed by GitLab](../user/project/clusters/index.md#gitlab-managed-clusters).
346
To follow progress on support for GitLab-managed clusters, see the
347
348
[relevant issue](https://gitlab.com/gitlab-org/gitlab/issues/38054).

349
350
351
352
353
354
355
356
### Complete example

The configuration in this section provides a full development workflow where your app is:

- Tested.
- Built.
- Deployed as a Review App.
- Deployed to a staging server once the merge request is merged.
357
- Finally, able to be manually deployed to the production server.
358

359
360
361
362
363
The following combines the previous configuration examples, including:

- Defining [simple environments](#defining-environments) for testing, building, and deployment to staging.
- Adding [manual actions](#configuring-manual-deployments) for deployment to production.
- Creating [dynamic environments](#configuring-dynamic-environments) for deployments for reviewing.
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379

```yaml
stages:
  - test
  - build
  - deploy

test:
  stage: test
  script: echo "Running tests"

build:
  stage: build
  script: echo "Building the app"

deploy_review:
380
  stage: deploy
381
  script:
382
    - echo "Deploy a review app"
383
  environment:
384
    name: review/$CI_COMMIT_REF_NAME
385
    url: https://$CI_ENVIRONMENT_SLUG.example.com
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
  only:
    - branches
  except:
    - master

deploy_staging:
  stage: deploy
  script:
    - echo "Deploy to staging server"
  environment:
    name: staging
    url: https://staging.example.com
  only:
  - master

deploy_prod:
  stage: deploy
  script:
    - echo "Deploy to production server"
  environment:
    name: production
    url: https://example.com
  when: manual
  only:
  - master
411
412
```

413
A more realistic example would also include copying files to a location where a
414
webserver (for example, NGINX) could then access and serve them.
415
416

The example below will copy the `public` directory to `/srv/nginx/$CI_COMMIT_REF_SLUG/public`:
417
418
419
420
421

```yaml
review_app:
  stage: deploy
  script:
422
    - rsync -av --delete public /srv/nginx/$CI_COMMIT_REF_SLUG
423
  environment:
424
425
    name: review/$CI_COMMIT_REF_NAME
    url: https://$CI_COMMIT_REF_SLUG.example.com
426
427
```

428
429
430
This example requires that NGINX and GitLab Runner are set up on the server this job will run on.

NOTE: **Note:**
431
432
See the [limitations](#limitations) section for some edge cases regarding the naming of
your branches and Review Apps.
433

434
The complete example provides the following workflow to developers:
435
436

- Create a branch locally.
437
- Make changes and commit them.
438
439
440
- Push the branch to GitLab.
- Create a merge request.

441
Behind the scenes, GitLab Runner will:
442
443
444
445
446

- Pick up the changes and start running the jobs.
- Run the jobs sequentially as defined in `stages`:
  - First, run the tests.
  - If the tests succeed, build the app.
447
  - If the build succeeds, the app is deployed to an environment with a name specific to the
448
449
450
451
452
    branch.

So now, every branch:

- Gets its own environment.
453
- Is deployed to its own unique location, with the added benefit of:
454
455
456
  - Having a [history of deployments](#viewing-deployment-history).
  - Being able to [rollback changes](#retrying-and-rolling-back) if needed.

457
For more information, see [Using the environment URL](#using-the-environment-url).
458
459
460
461
462
463
464
465
466

### Protected environments

Environments can be "protected", restricting access to them.

For more information, see [Protected environments](environments/protected_environments.md).

## Working with environments

467
468
Once environments are configured, GitLab provides many features for working with them,
as documented below.
469
470
471

### Viewing environments and deployments

472
A list of environments and deployment statuses is available on each project's **Operations > Environments** page.
473
474
475
476
477
478
479
480
481
482

For example:

![Environment view](img/environments_available.png)

This example shows:

- The environment's name with a link to its deployments.
- The last deployment ID number and who performed it.
- The job ID of the last deployment with its respective job name.
483
- The commit information of the last deployment, such as who committed it, to what
484
485
  branch, and the Git SHA of the commit.
- The exact time the last deployment was performed.
486
487
- A button that takes you to the URL that you defined under the `environment` keyword
  in `.gitlab-ci.yml`.
488
489
490
491
492
493
494
495
496
497
498
- A button that re-deploys the latest deployment, meaning it runs the job
  defined by the environment name for that specific commit.

The information shown in the **Environments** page is limited to the latest
deployments, but an environment can have multiple deployments.

> **Notes:**
>
> - While you can create environments manually in the web interface, we recommend
>   that you define your environments in `.gitlab-ci.yml` first. They will
>   be automatically created for you after the first deploy.
499
500
> - The environments page can only be viewed by users with [Reporter permission](../user/permissions.md#project-members-permissions)
>   and above. For more information on permissions, see the [permissions documentation](../user/permissions.md).
501
502
503
504
505
506
507
508
> - Only deploys that happen after your `.gitlab-ci.yml` is properly configured
>   will show up in the **Environment** and **Last deployment** lists.

### Viewing deployment history

GitLab keeps track of your deployments, so you:

- Always know what is currently being deployed on your servers.
509
- Can have the full history of your deployments for every environment.
510

511
512
Clicking on an environment shows the history of its deployments. Here's an example **Environments** page
with multiple deployments:
513

514
515
516
517
![Deployments](img/deployments_view.png)

This view is similar to the **Environments** page, but all deployments are shown. Also in this view
is a **Rollback** button. For more information, see [Retrying and rolling back](#retrying-and-rolling-back).
518

519
### Retrying and rolling back
520

521
If there is a problem with a deployment, you can retry it or roll it back.
522

523
To retry or rollback a deployment:
524

525
526
1. Navigate to **Operations > Environments**.
1. Click on the environment.
527
528
529
1. In the deployment history list for the environment, click the:
   - **Retry** button next to the last deployment, to retry that deployment.
   - **Rollback** button next to a previously successful deployment, to roll back to that deployment.
530

531
532
533
534
535
536
537
#### What to expect with a rollback

Pressing the **Rollback** button on a specific commit will trigger a _new_ deployment with its
own unique job ID.

This means that you will see a new deployment that points to the commit you are rolling back to.

538
539
NOTE: **Note:**
The defined deployment process in the job's `script` determines whether the rollback succeeds or not.
540

541
### Using the environment URL
542

543
The [environment URL](yaml/README.md#environmenturl) is exposed in a few
544
places within GitLab:
545
546
547
548
549
550
551

- In a merge request widget as a link:
  ![Environment URL in merge request](img/environments_mr_review_app.png)
- In the Environments view as a button:
  ![Environment URL in environments](img/environments_available.png)
- In the Deployments view as a button:
  ![Environment URL in deployments](img/deployments_view.png)
552

553
554
555
556
557
558
You can see this information in a merge request itself if:

- The merge request is eventually merged to the default branch (usually `master`).
- That branch also deploys to an environment (for example, `staging` or `production`).

For example:
559
560
561

![Environment URLs in merge request](img/environments_link_url_mr.png)

562
#### Going from source files to public pages
Douwe Maan's avatar
Douwe Maan committed
563

Marcia Ramos's avatar
Marcia Ramos committed
564
With GitLab's [Route Maps](review_apps/index.md#route-maps) you can go directly
565
from source files to public pages in the environment set for Review Apps.
Marcia Ramos's avatar
Marcia Ramos committed
566

567
### Stopping an environment
568

569
Stopping an environment:
570

571
572
- Moves it from the list of **Available** environments to the list of **Stopped**
  environments on the [**Environments** page](#viewing-environments-and-deployments).
573
- Executes an [`on_stop` action](yaml/README.md#environmenton_stop), if defined.
574

575
576
This is often used when multiple developers are working on a project at the same time,
each of them pushing to their own branches, causing many dynamic environments to be created.
577

578
NOTE: **Note:**
579
Starting with GitLab 8.14, dynamic environments are stopped automatically
580
581
582
583
584
when their associated branch is deleted.

#### Automatically stopping an environment

Environments can be stopped automatically using special configuration.
585

586
Consider the following example where the `deploy_review` job calls `stop_review`
587
588
589
590
to clean up and stop the environment:

```yaml
deploy_review:
591
592
  stage: deploy
  script:
593
    - echo "Deploy a review app"
594
  environment:
595
    name: review/$CI_COMMIT_REF_NAME
596
    url: https://$CI_ENVIRONMENT_SLUG.example.com
597
    on_stop: stop_review
598
599
600
601
  only:
    - branches
  except:
    - master
602
603

stop_review:
604
  stage: deploy
605
606
  variables:
    GIT_STRATEGY: none
607
608
  script:
    - echo "Remove review app"
609
610
  when: manual
  environment:
611
    name: review/$CI_COMMIT_REF_NAME
612
613
    action: stop
```
614

615
616
617
Setting the [`GIT_STRATEGY`](yaml/README.md#git-strategy) to `none` is necessary in the
`stop_review` job so that the [GitLab Runner](https://docs.gitlab.com/runner/) won't
try to check out the code after the branch is deleted.
618

619
When you have an environment that has a stop action defined (typically when
620
the environment describes a Review App), GitLab will automatically trigger a
621
stop action when the associated branch is deleted. The `stop_review` job must
622
be in the same `stage` as the `deploy_review` job in order for the environment
623
to automatically stop.
624

625
You can read more in the [`.gitlab-ci.yml` reference](yaml/README.md#environmenton_stop).
626

627
### Grouping similar environments
628

629
> [Introduced](https://gitlab.com/gitlab-org/gitlab-foss/-/merge_requests/7015) in GitLab 8.14.
630

631
632
633
As documented in [Configuring dynamic environments](#configuring-dynamic-environments), you can
prepend environment name with a word, followed by a `/`, and finally the branch
name, which is automatically defined by the `CI_COMMIT_REF_NAME` variable.
634

635
636
In short, environments that are named like `type/foo` are all presented under the same
group, named `type`.
637

638
639
In our [minimal example](#example-configuration), we named the environments `review/$CI_COMMIT_REF_NAME`
where `$CI_COMMIT_REF_NAME` is the branch name. Here is a snippet of the example:
640
641
642
643
644
645
646

```yaml
deploy_review:
  stage: deploy
  script:
    - echo "Deploy a review app"
  environment:
647
    name: review/$CI_COMMIT_REF_NAME
648
649
```

650
In this case, if you visit the **Environments** page and the branches
651
652
653
exist, you should see something like:

![Environment groups](img/environments_dynamic_groups.png)
654

655
### Monitoring environments
656

657
If you have enabled [Prometheus for monitoring system and response metrics](../user/project/integrations/prometheus.md),
658
659
660
661
662
663
you can monitor the behavior of your app running in each environment. For the monitoring
dashboard to appear, you need to Configure Prometheus to collect at least one
[supported metric](../user/project/integrations/prometheus_library/index.md).

NOTE: **Note:**
Since GitLab 9.2, all deployments to an environment are shown directly on the monitoring dashboard.
664

665
666
Once configured, GitLab will attempt to retrieve [supported performance metrics](../user/project/integrations/prometheus_library/index.md)
for any environment that has had a successful deployment. If monitoring data was
667
successfully retrieved, a **Monitoring** button will appear for each environment.
668

669
![Environment Detail with Metrics](img/deployments_view.png)
670

671
Clicking on the **Monitoring** button will display a new page showing up to the last
672
673
674
8 hours of performance data. It may take a minute or two for data to appear
after initial deployment.

675
All deployments to an environment are shown directly on the monitoring dashboard,
676
677
which allows easy correlation between any changes in performance and new
versions of the app, all without leaving GitLab.
678
679
680

![Monitoring dashboard](img/environments_monitoring.png)

Reuben Pereira's avatar
Reuben Pereira committed
681
682
683
684
#### Linking to external dashboard

Add a [button to the Monitoring dashboard](../user/project/operations/linking_to_an_external_dashboard.md) linking directly to your existing external dashboards.

685
686
687
688
#### Embedding metrics in GitLab Flavored Markdown

Metric charts can be embedded within GitLab Flavored Markdown. See [Embedding Metrics within GitLab Flavored Markdown](../user/project/integrations/prometheus.md#embedding-metric-charts-within-gitlab-flavored-markdown) for more details.

689
690
691
### Web terminals

> Web terminals were added in GitLab 8.15 and are only available to project Maintainers and Owners.
692

693
694
695
If you deploy to your environments with the help of a deployment service (for example,
the [Kubernetes integration](../user/project/clusters/index.md)), GitLab can open
a terminal session to your environment.
696

697
698
This is a powerful feature that allows you to debug issues without leaving the comfort
of your web browser. To enable it, just follow the instructions given in the service integration
699
documentation.
700
701
702
703
704
705
706
707
708
709
710
711
712
713

Once enabled, your environments will gain a "terminal" button:

![Terminal button on environment index](img/environments_terminal_button_on_index.png)

You can also access the terminal button from the page for a specific environment:

![Terminal button for an environment](img/environments_terminal_button_on_show.png)

Wherever you find it, clicking the button will take you to a separate page to
establish the terminal session:

![Terminal page](img/environments_terminal_page.png)

714
715
This works just like any other terminal. You'll be in the container created
by your deployment so you can:
716

717
718
719
- Run shell commands and get responses in real time.
- Check the logs.
- Try out configuration or code tweaks etc.
720

721
722
You can open multiple terminals to the same environment, they each get their own shell
session and even a multiplexer like `screen` or `tmux`.
723

724
725
726
727
NOTE: **Note:**
Container-based deployments often lack basic tools (like an editor), and may
be stopped or restarted at any time. If this happens, you will lose all your
changes. Treat this as a debugging tool, not a comprehensive online IDE.
728

729
### Check out deployments locally
730

731
Since GitLab 8.13, a reference in the Git repository is saved for each deployment, so
Nick Thomas's avatar
Nick Thomas committed
732
knowing the state of your current environments is only a `git fetch` away.
733

734
In your Git configuration, append the `[remote "<your-remote>"]` block with an extra
735
736
fetch line:

737
```text
738
739
740
fetch = +refs/environments/*:refs/remotes/origin/environments/*
```

741
### Scoping environments with specs
742

743
744
> - [Introduced](https://gitlab.com/gitlab-org/gitlab/-/merge_requests/2112) in [GitLab Premium](https://about.gitlab.com/pricing/) 9.4.
> - [Scoping for environment variables was moved to Core](https://gitlab.com/gitlab-org/gitlab-foss/-/merge_requests/30779) to Core in GitLab 12.2.
Marcia Ramos's avatar
Marcia Ramos committed
745
746
747
748
749
750
751
752
753
754
755
756
757
758
759
760

You can limit the environment scope of a variable by
defining which environments it can be available for.

Wildcards can be used, and the default environment scope is `*`, which means
any jobs will have this variable, not matter if an environment is defined or
not.

For example, if the environment scope is `production`, then only the jobs
having the environment `production` defined would have this specific variable.
Wildcards (`*`) can be used along with the environment name, therefore if the
environment scope is `review/*` then any jobs with environment names starting
with `review/` would have that particular variable.

Some GitLab features can behave differently for each environment.
For example, you can
761
[create a secret variable to be injected only into a production environment](variables/README.md#limiting-environment-scopes-of-environment-variables).
762
763
764
765
766
767
768
769
770
771
772
773
774
775
776
777
778
779
780
781
782
783
784

In most cases, these features use the _environment specs_ mechanism, which offers
an efficient way to implement scoping within each environment group.

Let's say there are four environments:

- `production`
- `staging`
- `review/feature-1`
- `review/feature-2`

Each environment can be matched with the following environment spec:

| Environment Spec | `production` | `staging` | `review/feature-1` | `review/feature-2` |
|:-----------------|:-------------|:----------|:-------------------|:-------------------|
| *                | Matched      | Matched   | Matched            | Matched            |
| production       | Matched      |           |                    |                    |
| staging          |              | Matched   |                    |                    |
| review/*         |              |           | Matched            | Matched            |
| review/feature-1 |              |           | Matched            |                    |

As you can see, you can use specific matching for selecting a particular environment,
and also use wildcard matching (`*`) for selecting a particular environment group,
Marcia Ramos's avatar
Marcia Ramos committed
785
such as [Review Apps](review_apps/index.md) (`review/*`).
786
787
788
789
790

NOTE: **Note:**
The most _specific_ spec takes precedence over the other wildcard matching.
In this case, `review/feature-1` spec takes precedence over `review/*` and `*` specs.

791
792
793
794
795
### Environments Dashboard **(PREMIUM)**

See [Environments Dashboard](environments/environments_dashboard.md) for a summary of each
environment's operational health.

796
797
## Limitations

798
799
In the `environment: name`, you are limited to only the [predefined environment variables](variables/predefined_variables.md).
Re-using variables defined inside `script` as part of the environment name will not work.
800

801
802
803
804
805
## Further reading

Below are some links you may find interesting:

- [The `.gitlab-ci.yml` definition of environments](yaml/README.md#environment)
806
- [A blog post on Deployments & Environments](https://about.gitlab.com/blog/2016/08/26/ci-deployment-and-environments/)
807
- [Review Apps - Use dynamic environments to deploy your code for every branch](review_apps/index.md)
808
- [Deploy Boards for your applications running on Kubernetes](../user/project/deploy_boards.md) **(PREMIUM)**
Marcia Ramos's avatar
Marcia Ramos committed
809
810
811
812
813
814
815
816
817
818
819
820

<!-- ## Troubleshooting

Include any troubleshooting steps that you can foresee. If you know beforehand what issues
one might have when setting this up, or when something is changed, or on upgrading, it's
important to describe those, too. Think of things that may go wrong and include them here.
This is important to minimize requests for support, and to avoid doc comments with
questions that you know someone might ask.

Each scenario can be a third-level heading, e.g. `### Getting error message X`.
If you have none to add when creating a doc, leave this section in place
but commented out to help encourage others to add to it in the future. -->