GitLab CI/CD: Pipelines, CI/CD and DevOps for Beginners

Learn continuous integration by building a from-scratch CI pipeline with GitLab, Docker, linting, and unit tests, focusing on merging changes from multiple developers and quick feedback.

Fork a GitLab repository to create your personal copy, set public visibility in your username dash project group, and practice building pipelines and CI/CD workflows for a React JS project.

Publish the build directory as a job artifact in GitLab CI/CD, so the website files are accessible after execution. Practice by completing the assignment on your own.

Define a new test stage and a test_artifact job using an alpine image. Run a file-existence test with -f for build/index.html and pass artifacts between jobs to verify pipeline integrity.

Master unit tests at the base of the testing pyramid and automate them with npm test and vitest in a GitLab CI pipeline for continuous integration.

Speed up GitLab CI/CD pipelines by running unit tests and test jobs in parallel, using two stages, improving maintainability and quick access to pipeline status via the built pipelines pane.

Explore how GitLab CI/CD uses default stages (pre, build, test, deploy, post) and how pipelines run even after removing explicit stages, thanks to GitLab's built-in stage definitions.

Integrate changes safely by using feature branches and automated GitLab pipelines that test before merging the main branch, with merge requests for peer review.

Configure merge requests in GitLab by selecting fast forward merge, enabling squashing, enforcing pipeline success and resolved discussions, and securing the main branch through protected branches and fork target settings.

Create your first merge request by branching from main, committing changes, and validating pipelines and tests, with clear titles, descriptions, templates, labels, and merge options.

Perform code reviews and merge changes via GitLab merge requests, comments, and discussions. Run pipelines and tests, then merge to main with clean commits.

Understand how a linter like ESLint enforces coding consistency in a GitLab CI/CD pipeline, generating a code quality report and integrating with merge requests.

Structure a GitLab CI pipeline by ordering stages and jobs to optimize execution, respect dependencies between build and test artifacts. Favor failing fast and balance parallelism across stages.

Simplify the GitLab CI/CD pipeline by disabling the test stage, creating a minimal alpine build with an index.html, and running the first job early to speed up feedback.

Learn how continuous integration drives a solid CI pipeline that builds and tests the application, and how merge requests protect the main branch through a review process.

Deploy a website to the cloud with a CI/CD pipeline on Netlify, building and testing serverless deployments while practicing continuous delivery and GitLab features include review environments and merge requests.

Download the zip, extract the build directory, and perform a manual Netlify deployment by uploading it, configuring a unique site name with your GitLab prefix, and verifying the deployment URL.

Learn to manage environment variables in ci/cd lab by checking definitions with echo and env, exporting a version, and creating an info.txt with the text 'Build version one two, three'.

Store credentials in a secure store like gitlab instead of embedding them in pipeline configuration, enable environment-specific variables, and rely on masking to prevent credential exposure in logs for compliance.

Explore content verification with curl by fetching a page, distinguishing static from rendered content, and validating text with grep, while handling http vs https and silent mode in CI/CD workflows.

Learn how to test deployments in non-production environments such as dev, QA, and staging before going live, and use preview environments for merge requests to protect production.

Create automatic review environments for every merge request to preview changes in a realistic setting before merge, using a deploy review stage with Netlify and live preview URLs.

Switch from a branch pipeline to a merge request pipeline by configuring a workflow that uses CI_PIPELINE_SOURCE and CI_COMMIT_BRANCH. Run build, test, and deploy_review for merge requests only.

Define static deploy environments for staging and production in GitLab using YAML configuration and the UI. Use environment variables and URLs to manage deployments and diagnose issues.

Replace manual checks with automated end-to-end tests using Playwright in a GitLab CI/CD pipeline. Configure APP_BASE_URL via environment variables and run npm run e2e with the Playwright docker image.

Learn to pass environment variables between GitLab pipeline jobs using a dot env artifact. Share the review URL with downstream end-to-end tests and inject it where needed.

Learn how to publish the end-to-end JUnit report for Playwright tests in GitLab CI/CD, using artifact publishing and selective pipeline rules to exclude the main pipeline.

Learn how to publish HTML reports from GitLab CI/CD using artifacts, access the Playwright HTML report in the post_deploy_review stage, and consider potential CSRF-related issues and the GitLab Pages alternative.

Review the GitLab CI/CD pipeline execution time, optimize deployments by preinstalling dependencies with a custom docker image, and use reusable templates and environment variables to reduce duplication.

Learn to create a Dockerfile that builds a custom docker image for a ci pipeline, using from and run instructions to install npm dependencies and curl.

Push a Docker image to the GitLab container registry using the fully qualified name and the CI registry image variable, then verify the published latest tag.

Use a custom docker image in the pipeline to replace deployment images, pin Netlify CLI version, leverage environment variables, and speed up deploys while avoiding breaking changes.

Learn to configure a scheduled pipeline that builds a Docker image once per day, week, or cron-based schedule and uses a rule to exclude that job from daily runs.

Explore Amazon S3 as the simple storage service for DevOps, learning how to create a unique bucket, store objects, and serve public files over HTTP.

Learn to upload files to S3 from a GitLab pipeline using the official AWS CLI Docker image, override the entry point, and pin a fixed version for stable builds.

Learn how to use the AWS CLI to list s3 bucket contents, navigate the AWS CLI reference, handle credentials, and read documentation to solve real aws tasks.

Add aws access key id and secret access key as environment variables in GitLab, protect on main, then retry the job to verify S3 access.

Learn how to upload a local file to an S3 bucket using the AWS CLI in a GitLab pipeline, with a simple index.html and environment variable bucket name.

Use S3 sync to upload the build directory to a target bucket, replacing old files during the deploy stage and deploying the site to AWS.

Explore how a simple pipeline builds and deploys a static website to the AWS cloud, using S3 for storage and web hosting, and mastering the AWS CLI for deployment tasks.

Run commands remotely over SSH in GitLab CI pipeline, moving setup steps into before script and executing commands like who am I, touch, and ls on the remote server.

Establish ssh connections by generating an ssh key pair and storing the private key in GitLab. Verify authenticity with a known hosts file and transfer files using scp or rsync.

Explore how Amazon ECS lets you deploy containerized applications on the AWS cloud using Docker containers, with clusters and task definitions, without managing servers.

Explore ECS infrastructure with two launch modes—EC2 and Fargate (serverless)—comparing container management, cost implications, and practical steps using the AWS calculator for planning.

Create a Dockerfile, build the image with the docker build command, push to Amazon Elastic Container Registry, and deploy to ECS using a GitLab pipeline to automate.

Learn to store docker images in Amazon Elastic Container Registry (ECR) by creating a repository and tagging images. Authenticate with AWS ECR using get-login-password and push to the private registry.

Learn how to align a Docker image built in ECR with an ECS task definition, replacing the Nginx image from Docker Hub, handling execution roles, tags, and deployment rollbacks.

Learn how to use the allow_failure keyword to let non-critical jobs fail without stopping the pipeline, or other pipelines, refine with exit_codes, and optionally retry to decide final status.

Explore yaml anchors and aliases to reduce duplication in GitLab CI/CD pipelines, using anchors, aliases, and merge keys to create reusable templates and common blocks like dependencies and before_script.

Master YAML anchors and aliases to create reusable deploy templates for staging and production in GitLab CI/CD, apply the dry principle, and override environment and variables with the merge key.

Explore how extends reuses configuration to create modular job templates in GitLab CI/CD, inheriting from a template and merging variables automatically while overriding environment, stage, and script as needed.

The lecture introduces GitLab's include feature to simplify and reuse pipeline configurations by splitting yaml files into local, remote, and project includes, with practical setup examples.

Explore how git strategy none skips repository setup in GitLab CI/CD, reducing time by avoiding git clone or fetch, and compare Job 1 and Job 2 to see faster execution.

Explore stageless pipelines in GitLab CI/CD by using the needs keyword to run jobs out of order, enabling parallel execution and faster pipelines through explicit dependencies.

Explore how caches speed GitLab CI/CD pipelines by storing dependencies like node_modules, enabling reuse across jobs while noting caching overhead and best practices.

Compare caches and artifacts to understand their distinct roles in GitLab CI/CD: caches speed up jobs by reusing files, while artifacts pass files between jobs.