I’d suggest setting up your runners using the docker executor - https://docs.gitlab.com/runner/executors/docker.html This allows your runner to start up fresh containers for jobs with the image you specify, meaning jobs aren’t running on the host and can have whatever you need. You can then also use a single runner with parallelism instead of multiple runners. Downside is that if you need to install extras they will need to install as part of the CI on every job. More on reddit.com

I'm using CloudFoundry for deploying my services, and my E2E tests are done with Postman (Newman on CLI). The situation is that I do not have access directly to some services from my GitLab CI/CD, ... More on stackoverflow.com

https://docs.gitlab.com/ee/ci/ GitLab reads the .gitlab-ci.yml file on the branch that you pushed, or the default yaml defined by AutoDevOps if you have that enabled. The push triggers a pipeline, which creates jobs in stages. There are other potential triggers as well, for example scheduled jobs, API calls, or merge requests. You register a runner using a secret registration token generated in your project or group settings. The GitLab admins can also set up shared runners. If you’re using GitLab.com this is provided for you. The runner polls the GitLab API asking for jobs. When a pipeline creates jobs in step 2, runner(s) pick up the jobs and begin executing. You can have multiple runners so you can run jobs in parallel and have high availability. The runner evaluates all of the variables you have defined in project/group settings or the various overrides in variables: yaml and sets them as environment variables. For a script runner, it then simply executes your shell script. A docker runner creates a container using the image you specify and runs your shell script inside of it; a kubernetes runner runs a Pod (there is a little more complexity here as it has to create volumes and helper containers to get your data in and out). The advantage of a docker/kubernetes runner is the developer has total control over the build image and the tools installed and available for the build; also you get a clean and 100% reproducible build each time. With a shell runner, you have to install your build tools by hand; upgrading tools affects all projects/branches using that runner simultaneously; it’s easy to break something or have an unreproducible build. Unless you totally automate the runner set up (hurray, you just reinvented the wheel!) this makes script runners a liability. However, with docker/k8s runners you have to think about caching to speed up your builds since, as mentioned, you get a clean build directory each time. Usually, devs don’t have to think about any of this, it’s all happening behind the scenes. Your script (which can do whatever you want) creates the image just like you would on the command line on your PC, and pushes to a registry of your choice. If you use GitLab’s registry, the registry user/password are helpfully passed in as environment variables. There are some complexities if you’re using a docker/kubernetes runner as you might want to use a tool like Kaniko, Buildah, Jib Maven, Skaffold, etc. to build a docker image without docker (Otherwise in order to run “docker build” you’d need to run the docker runner in “privileged” mode to get docker-in-docker, which may be a security issue. This does work on GitLab.com, but in my organization privileged mode was not allowed.) If you are using AutoDevOps this is all done automatically. More on reddit.com

I think the /builds directory is shadowed by a volume mounted there. You can configure a custom builds_dir in the gitlab-runner config. https://docs.gitlab.com/runner/configuration/advanced-configuration.html#the-runners-section More on reddit.com