Course Overview
This course is neither endorsed by, nor in partnership, nor affiliated with GitLab, Inc.
SPECIFIC SKILLS YOU WILL LEARN
Pipeline Development - Create multi-stage GitLab CI/CD pipelines using YAML configuration. Configure automated unit testing with JUnit reports. Implement parallel job execution. Use conditional job execution with rules. Manage job dependencies and artifacts. Configure before_script and after_script hooks. Troubleshoot pipeline failures using exit codes.
Continuous Integration Practices - Configure merge request workflows with branch protection. Implement code review processes before merging. Add automated code linting for quality enforcement. Run unit tests before allowing merges. Generate and publish test reports. Implement smoke tests for deployment verification. Configure end-to-end testing with Playwright.
Docker Integration - Select appropriate Docker images for build environments (Alpine, slim variants). Create custom Dockerfile for applications. Build and tag Docker images in GitLab pipelines. Push images to GitLab Container Registry and Amazon ECR. Use Docker containers as pipeline job execution environments.
Deployment Strategies - Create deployment pipelines for multiple environments. Configure environment-specific variables and secrets. Implement manual approval gates for production deployments. Create dynamic review environments for merge requests. Deploy applications to remote servers using SSH, SCP, and rsync. Configure SSH key authentication and host verification. Run deployment scripts on remote servers.
AWS Cloud Deployment - Install and configure AWS CLI for infrastructure automation. Deploy static websites to Amazon S3 with bucket configuration and file syncing. Create and manage AWS IAM users and roles for secure credential management. Deploy containerized applications to Amazon ECS using Fargate and EC2 launch types. Create ECS task definitions and services. Update ECS deployments using AWS CLI. Store Docker images in Amazon ECR.
Pipeline Optimization - Implement caching strategies to speed up builds. Configure cache keys (static, dynamic, file-based). Manage artifact dependencies between jobs. Use stageless pipelines with the needs keyword. Skip repository cloning when not needed using GIT_STRATEGY. Optimize Docker image selection for faster execution.
Security and Secrets Management - Store credentials securely using GitLab CI/CD variables. Scope variables to specific environments. Follow best practices for handling sensitive data. Configure SSH private keys for deployment. Manage AWS access keys and secret keys safely.
COURSE STRUCTURE
Section 1 (21 lectures) - GitLab CI/CD fundamentals, DevOps concepts, pipeline architecture, YAML syntax, first pipeline creation, GitLab Runner understanding, Linux shell basics, exit codes.
Section 2 (25 lectures) - Continuous Integration with Docker build environments, automated testing, parallel execution, JUnit reports, merge request workflows, code linting, artifact publishing.
Section 3 (33 lectures) - Continuous Deployment to multiple environments, environment variables, secrets management, deployment strategies (manual, staging, production), review environments, Playwright E2E testing, HTML reports.
Section 4 (9 lectures) - Docker for DevOps including Dockerfile creation, Docker CLI in GitLab, building and pushing images, GitLab Container Registry, scheduled pipelines.
Section 5 (11 lectures) - AWS deployment using S3 static hosting, AWS CLI usage, IAM credential management, file uploading and syncing to S3.
Section 6 (12 lectures) - SSH deployment to Amazon EC2, Nginx web server setup, SSH connection configuration, SCP and rsync file transfers, remote script execution.
Section 7 (15 lectures) - Amazon ECS deployment including cluster creation, task definitions, service configuration, ECR integration, automated deployment updates, sed for file templating.
Section 8 (11 lectures) - Advanced features including job retry, allow_failure, YAML anchors and aliases, job templates, extends keyword, includes for configuration reuse, CI/CD components, multi-line scripts, background processes, GitLab Pages, runner tags.
Section 9 (12 lectures) - Performance optimization including GIT_STRATEGY options, disabling artifact downloads, stageless pipelines with needs, cache configuration (keys, policies, troubleshooting), cache vs artifacts comparison.
Section 10 (1 lecture) - User questions and specific topics.
Section 11 (3 lectures) - Course conclusion and bonus content.
PRACTICE COMPONENTS
The course includes quizzes testing fundamental concepts, GitLab architecture, Docker integration, merge requests, deployment environments, and CI/CD best practices. Practice labs cover Linux commands, environment variables, curl for smoke testing, and JSON parsing with jq. Role-play exercises simulate real DevOps scenarios. Assignments include publishing build artifacts, adding test stages, publishing test reports, and managing AWS credentials with step-by-step solutions provided.
WORKPLACE APPLICATIONS
Automate manual deployment processes that are error-prone and time-consuming. Maintain consistent environments across development, staging, and production using Docker containers. Integrate AWS cloud services with CI/CD pipelines. Implement automated testing before code merges to prevent production bugs. Optimize pipeline execution speed to improve developer productivity. Establish deployment approval workflows for production releases. Create ephemeral review environments for feature branch testing. Implement infrastructure-as-code practices for reproducible deployments.
LEARNING APPROACH
This course provides foundational knowledge in GitLab CI/CD rather than promising instant expertise. It focuses on clear explanations of CI/CD concepts, step-by-step pipeline building guidance, practical examples applicable to real projects, troubleshooting common issues, and best practices for security, performance, and maintainability. The course emphasizes hands-on learning through building actual pipelines rather than theoretical knowledge alone.
COMPLEMENTARY SKILLS
This course connects to broader DevOps practices including infrastructure automation, containerization strategies, cloud architecture, automated testing methodologies, continuous delivery vs continuous deployment, version control workflows, and deployment pattern implementations. Skills learned apply to GitLab CI/CD specifically but transfer to understanding Jenkins, GitHub Actions, CircleCI, and other CI/CD platforms.
EXPECTED OUTCOMES AFTER COMPLETION
You will be able to create GitLab CI/CD pipelines from scratch for your projects. You will automate testing, building, and deployment workflows. You will deploy applications to AWS cloud infrastructure using multiple services. You will implement merge request workflows with automated quality checks. You will configure secure credential management for cloud deployments. You will optimize pipeline performance for faster execution. You will troubleshoot and debug pipeline failures independently. You will apply CI/CD best practices in professional development environments.
WHAT YOU WILL BUILD
Production-ready CI/CD pipelines that automate software testing, building, and deployment from code commit to production release across multiple environments (development, staging, production).
PREREQUISITES
Basic Git version control knowledge (commits, branches, push, pull). Familiarity with command-line interfaces and Linux/Unix terminal basics. Basic programming or scripting knowledge in any language. Docker experience, cloud platform knowledge, and software development workflow understanding are helpful but not required.
TARGET LEARNERS
Software Developers, DevOps Engineers, Site Reliability Engineers (SRE), System Administrators, Cloud Engineers seeking to automate testing, building, and deployment workflows.
CORE TECHNOLOGIES COVERED
GitLab CI/CD pipelines, YAML configuration, Docker containers, AWS S3, AWS ECS, AWS ECR, AWS IAM, AWS CLI, Amazon EC2, SSH deployment, SCP, rsync, Playwright end-to-end testing, JUnit test reports, GitLab Container Registry, GitLab Runner, merge request workflows, code linters, pipeline optimization, caching strategies, environment variables, secrets management.
Legal Disclaimer
This course is an independent educational resource and is not endorsed by, affiliated with, or associated with GitLab Inc. or any of its products or services. GitLab and the GitLab logo are trademarks of GitLab Inc. All product names, logos, and brands mentioned in this course are the property of their respective owners.
This course contains promotional materials.
FAQ
FAQ area empty
Course curriculum
-
Introduction to the GitLab CI/CD course
202 Xem trước -
What is GitLab CI/CD?
204 Xem trước -
GitLab.com account registration
176 Xem trước -
Verifying your GitLab account
354 -
What is a pipeline?
102 -
Your first pipeline
628 Xem trước -
Help! My GitLab CI pipeline is not running.
-
Adding pipeline stages
714 -
Fundamental GitLab and CI/CD concepts
Xem trước -
GitLab CI/CD architecture
484 -
GitLab CI/CD architecture (Part 2)
353 -
How much does GitLab cost?
451 Xem trước -
GitLab architecture quiz
Xem trước -
What is a Linux shell?
169 -
Writing comments in a GitLab pipeline
94 -
Manually stopping a pipeline
194 -
Brief introduction to YAML
476 -
Safeguarding CI pipelines with effective tests
441 -
Why do jobs and pipelines fail (exit codes)
442 -
Basic Linux commands recap (practice lab)
357 -
Important skills you need to acquire
201 -
What is DevOps?
382 -
GitLab CI/CD and DevOps fundamentals
0 -
Conclusion
133
-
Introduction to Continuous Integration (CI)
278 -
Forking a Git repository
263 -
Running the project locally (optional)
712 -
Using Docker as a build environment
380 -
Choosing an appropriate Docker image
482 -
Lightweight Docker images (alpine, slim)
317 -
Building the project using GitLab
264 -
Docker as a build environment in GitLab CI/CD
-
Assignment: Publishing build artifacts
73 -
Assignment: Publishing build artifacts
192 -
Revisiting the GitLab CI/CD architecture
191 -
GitLab architecture quiz
-
Assignment: Adding a test stage
51 -
Assignment - Adding a test stage - Step by step instructions
-
Assignment: Adding a test stage - Solution
145 -
Running unit tests
344 -
Running jobs in parallel
180 -
Default pipeline stages (.pre, build, test, deploy .post)
149 -
Publishing a JUnit test report
419 -
Testing the tests (ensure that the tests fail!)
369 -
The role of unit tests in CI pipelines
-
How to integrate changes?
302 -
Configuring Merge Requests
222 -
Making changes through a Merge Request
445 -
Code review and merging changes
542 -
Merge requests
-
Configuring a code linter
424 -
How to structure a pipeline?
226 -
Understanding code linters
-
Simplifying the pipeline
205 -
Section recap
52
-
Section Overview
170 -
Manual deployment
118 -
Installing CLI tools
319 -
[ACTION REQUIRED] Important update regarding Netlify CLI
-
Storing project configuration in environment variables
410 -
Environment variables (practice lab)
257 -
Managing secrets
460 -
Best practices for handling credentials
253 -
Managing variables and secrets in GitLab
-
Deploying to production
266 -
Smoke tests
486 -
Basic app content checking with curl (practice lab)
324 -
Deployments with GitLab
-
Conditional job execution with rules:
396 -
Scripts: before_script and after_script
179 -
Deployment Strategies: Non-production environments
201 -
[ACTION NEEDED] Netlify permissions update
-
Deploying to the staging environment
342 -
Manual approval step before deploying to production
166 -
Continuous Delivery and Continuous Deployment
287 -
Creating review environments
265 -
Merge request pipeline vs Branch pipeline
899 -
Parsing CLI response data (w/ jq JSON parser)
635 -
Defining dynamic environments
595 -
Defining static environments
473 -
Scoping variables to a specific environment
101 -
CI/CD & Deployment environments
-
Project simulation using merge requests
560 -
End-to-end tests with Playwright (E2E tests)
420 -
Passing data between jobs with environment variables
305 -
Assignment: Publishing the E2E JUnit report
61 -
Publishing the E2E JUnit report - Step by step instructions
-
Assignment: Publishing the E2E JUnit report - Solution
251 -
Publishing an HTML report
191 -
End-to-End Testing in GitLab CI/CD
-
Setting a build version
331 -
A critical analysis of the pipeline
511 -
Why CI/CD really matters
375 -
CI/CD recap
-
Conclusion & coffee break
43
-
Section overview
111 -
Creating a Dockerfile
177 -
Running Docker CLI commands in GitLab
843 -
Building a Docker image
298 -
GitLab container registry
428 -
Pushing an image to the GitLab container registry
373 -
Using a custom Docker image in the pipeline
257 -
Create a scheduled pipeline
392 -
Microsoft Artifact Registry
202
-
Introduction to Amazon Web Services (AWS)
221 -
AWS Temporary Lab environment
214 -
Amazon S3 (object storage)
301 -
AWS CLI
687 -
Managing AWS services with AWS CLI
253 -
Identity management with AWS IAM
552 -
Managing AWS credentials in GitLab - Assignment
72 -
Assignment - Managing AWS credentials - Step by step instructions
-
Managing AWS credentials in GitLab - Assignment Solution
487 -
Uploading a file to S3
535 -
Hosting a website on S3
511 -
Syncing files to S3
260 -
Conclusion
125
-
Amazon Elastic Compute Cloud (EC2)
1102 -
Creating an Ngnix web server
563 -
Testing the connection with netcat (nc)
282 -
25 - Testing the SSH connection from GitLab
315 -
Storing the SSH private key in GitLab
460 -
Configuring the SSH connection
473 -
Verifying the SSH host keys
433 -
Running commands over SSH
167 -
Uploading files using SCP
551 -
Uploading fiels using rsync
272 -
Running a deployment script
500 -
Conclusion
159
-
Introduction to Amazon Elastic Container Service (Amazon ECS)
356 -
ECS Infrastructure / Launch modes (Fargate vs EC2)
329 -
Creating a cluster in ECS
103 -
Creating a task definition
572 -
Creating a deployment on ECS
409 -
Updating the task definition using AWS CLI
579 -
Updating the service using AWS CLI
519 -
Wait command
337 -
Steps needed to deploy an application to ECS
141 -
Creating the Dockerfile
176 -
Building the Docker image
411 -
Amazon ECR - Docker container registry
530 -
Using an ECR Docker image in the task definition
610 -
Using sed to replace placeholders in files
201 -
Section summary & conclusion
167
-
Section overview
67 -
Retrying failed jobs automatically (retry keyword)
354 -
Allowing failures (allow_failure keyword)
182 -
YAML anchors and aliases
564 -
Job templates with YAML anchors and aliases (practical example)
640 -
Reusing configuration with extends:
359 -
Import YAML configuration from other files (includes keyword)
482 -
CI/CD Components & Catalog
381 -
Writing multi-line scripts
439 -
Starting a server / background process within a job
413 -
GitLab Pages
354 -
Choosing the GitLab Runner using tags
389
-
Skip cloning the Git repository (GIT_STRATEGY)
412 -
Disabling artifact download from previous stages (dependencies keyword)
327 -
Stageless pipelines: running jobs out of order (needs keyword)
254 -
Using the needs keyword with artifacts
323 -
Caches
474 -
Caches vs Artifacts
131 -
Dynamic cache keys (cache configuration)
177 -
Cache key from file (cache configuration)
122 -
Disabling cache (cache configuration)
87 -
Cache policy (cache configuration)
205 -
Dynamic cache policy (cache configuration)
246 -
Troubleshooting the cache configuration
130
Requirment
-
Registering for a GitLab .com account (the free plan works very well)
-
Verifying your GitLab .com account by text message by providing a phone number.
-
Git basics (like configuring a repository locally, cloning, merge, commit, push)
-
Basic experience with Linux, Linux commands and using the terminal
-
Admin permissions that allow you to install additional tools (Node, npm, Docker)
-
Optional: Installing Visual Studio Code
-
Optional: Basic experience with Docker
Outcomes
-
What is a pipeline
-
What is Continuous Integration (CI), Continuous Delivery (CD) and Continuous Deployment (CD)
-
Automate your build, test & deployment with Gitlab CI
-
Learn industry "best practices" in building CI/CD pipelines
-
Demonstrate your understanding of building CI/CD pipelines to future employers
-
Automate your builds, tests, and deployments
-
Automatic deployments using AWS
-
Build pipelines with code quality checks, unit tests, API testing
-
Solve problems with hands-on assignments
-
Create Merge Requests and review code
-
Dynamic environments
0 Student
1 Course
0 review