- Interview Prep
- CI / CD
- Gitlab Python
- Security Scanning
- Create .gitlab-ci.yml file
- Gitlab alert and notification setup
- Gitlab CI/CD to manage different Python environments : Miniforge Conda
- Gitlab CI/CD for Data Version Control DVC to Machine Learning
- Gitlab Epic
- Gitlab CICD Secure password
- Secure Gitlab Pipeline
- Python code to get all active Gitlab active members in each GitLab group and Save to Single CSV
- Python code to get all Gitlab Project ID, Name and URL to CSV file
- Python GCP deploy
- Gitlab User Creation Automation
- Gitlab find repo not using pipeline
- Gitlab find projects use security scans
- Automate API Testing using Python
- GCP vs AWS
- Pytest API Automation
- Gitlab security best practices
- Gitlab SAST & DAST
- Gitlab CI Performance improvement Technique
Introduction to GitLab:
User Settings
Profile: This section allows users to manage personal information, including name, avatar, and status. It also includes visibility settings for how your profile appears to others.
Account: Account settings cover configurations related to your GitLab account, including username, email, and two-factor authentication settings.
Billing: View and manage billing information, subscription details, and payment methods associated with your GitLab account.
Applications: Manage applications linked to your GitLab account, including authorized OAuth applications and personal access tokens.
Chat: Configure chat integration settings to enable communication and collaboration within GitLab.
Access Tokens: Create and manage personal access tokens for secure authentication to GitLab services.
Emails: Configure email notification preferences, including settings for different types of notifications.
Password: Change or update the password associated with your GitLab account.
Notifications: Customize notification preferences, including email, push, and global notification settings.
SSH Keys: Manage SSH keys for secure access to GitLab repositories via SSH.
GPG Keys: Configure GPG keys for secure communication and signing of commits.
Preferences: General account preferences, including time zone, language, and theme settings.
Comment Templates: Manage templates for comments on issues and merge requests to ensure consistent communication.
Active Sessions: View and manage currently active sessions, including details about devices and IP addresses.
Authentication Log: A log of authentication events for tracking and auditing purposes.
Usage Quotas: Monitor and manage resource usage quotas to ensure compliance with allocated limits.
Your Work
Projects: Explore and manage personal and group projects, including project creation, settings, and collaboration.
Groups: Manage activities related to groups, such as group creation, settings, and membership management.
Issues: Create, track, and manage project issues, including assignment, labels, and due dates.
Merge Requests: Collaborate on code changes with merge requests, including code review, discussions, and approvals.
To-Do List: A personalized to-do list that consolidates tasks and assignments from various projects.
Milestones: Plan and track project milestones to ensure project progress and completion.
Snippets: Manage and share code snippets, including both public and private snippets.
Activity: Overview of personal and project-related activities, including events and updates.
Workspaces: Organize and manage collaborative workspaces, enabling efficient team collaboration.
Environments: Track and manage deployment environments for projects, ensuring consistency and stability.
Operations: Access and manage operational features, such as performance monitoring and tracing.
Security
Project: Security-related configurations specific to a project, including settings for vulnerability scanning and security policies.
Pinned Issues: A section highlighting priority issues that require attention and action.
Manage: Activity, members, and labels management for the project, including permissions and access control.
Plan
Issues: Creation and management of project issues, including tracking progress and assigning tasks.
Assignees:
- Definition: Assignees are individuals or teams responsible for completing a specific issue or merge request. Assigning someone makes it clear who is responsible for taking action on that item.
- Example: If an issue is created to implement a new feature, you might assign it to a developer who is responsible for implementing that feature. Multiple assignees are also possible if multiple people are working on the same task.
Epic:
- Definition: An Epic is a way to group related issues and milestones together. It's a high-level container for managing and tracking work that spans multiple issues or user stories.
- Example: If you have a large project that involves multiple features or user stories, you can create an Epic to encapsulate all related issues. For instance, an Epic could represent a major release or a theme of work.
Milestone:
- Definition: A Milestone is a way to track and organize issues or merge requests based on time or progress. It's often used to represent a specific point in time or a goal.
- Example: You might create a milestone for a specific release version or a sprint. Issues and merge requests can be associated with milestones to indicate their target completion or inclusion in a particular release.
Labels:
- Definition: Labels are used to categorize and filter issues, merge requests, and epics. They provide a way to quickly identify the nature or status of an item.
- Example: You can create labels like "bug," "feature," "documentation," or "priority: high." Applying labels helps in searching, filtering, and organizing work items based on their characteristics.
Weight:
- Definition: Weight is a relative measure of the effort or complexity associated with an issue or merge request. It allows teams to estimate and prioritize work based on the perceived level of effort.
- Example: You might use weights like 1, 2, 3, etc., to represent the complexity or effort required for an item. This can help in prioritizing tasks during sprint planning or backlog refinement.
Due Date:
- Definition: Due Date is the date by which an issue or merge request is expected to be completed. It helps set expectations for when a particular piece of work should be finished.
- Example: If you have a critical bug that needs to be fixed urgently, you can set a due date to ensure that the team is aware of the urgency and can prioritize accordingly.
Iteration:
- Definition: Iteration is a way to organize work into time-bound cycles, often used in Agile methodologies like Scrum. It helps in planning and delivering work in manageable increments.
- Example: In Scrum, an iteration is often referred to as a "sprint." You might plan your work in two-week sprints, and during each sprint, you aim to complete a set of prioritized issues or user stories.
Issue Boards: Visualize and manage issues on boards to facilitate project planning and collaboration.
Milestones: Plan and track project milestones, ensuring alignment with project goals and deadlines.
Iterations: Agile iteration planning, allowing teams to organize work in iterations.
Wiki: Collaborative documentation within the project, providing a centralized knowledge base.
Requirements: Manage and track project requirements, ensuring clarity and adherence to specifications.
Jira: Integration and interaction with Jira for seamless collaboration between GitLab and Jira users.
Code
Merge Requests: Review and merge code changes, including collaboration features like discussions and approvals.
Repository: Overview and settings for the project repository, including visibility and repository details.
Branches: Manage branches in the repository, including creation, deletion, and protection settings.
Commits: View and manage project commits, including commit history and details.
Tags: Tagging and versioning of repository releases, allowing for clear version management.
Repository Graph: Visual representation of the repository structure, showing branches and commit history.
Compare Revisions: Compare different revisions of code to understand changes over time.
Snippets: Manage and share code snippets, fostering code reusability and collaboration.
Locked Files: Secure and manage locked files to prevent accidental changes.
Build
Pipelines: Overview and management of CI/CD pipelines, including pipeline details and status.
Jobs: Details of individual CI/CD pipeline jobs, including job logs and artifacts.
Pipeline Editor: Visual editor for CI/CD pipeline configuration, simplifying pipeline setup.
Pipeline Schedules: Automated scheduling of pipeline runs, allowing for regular and controlled builds.
Test Cases: Manage and view test cases associated with CI/CD pipelines.
Artifacts: Storage and management of build artifacts, ensuring easy access and versioning.
Secure
Security Dashboard: Overview of project security status, including security metrics and insights.
Vulnerability Report: Detailed report on project vulnerabilities, enabling proactive security measures.
Dependency List: Management of project dependencies, ensuring awareness of third-party dependencies.
License Compliance: Ensure compliance with project licenses, managing licensing issues.
Audit Events: Logs and events related to security audits, providing visibility into security-related activities.
Policies: Define and manage security policies to enforce security standards and practices.
On-Demand Scans: Manual triggering of security scans for real-time vulnerability assessment.
Security Configuration: Configuration settings related to project security, including security features.
Deploy
Releases: Management of project releases, including versioning and release notes.
Feature Flags: Control feature rollout with feature flags, allowing for gradual deployment and testing.
Package Registry: Storage and management of project packages, facilitating package sharing and distribution.
Container Registry: Storage and management of container images for Docker and Kubernetes.
Pages: Hosting static web pages associated with the project.
Operate
Environments: Management of deployment environments, ensuring consistency across different stages.
Kubernetes Clusters: Integration and management of Kubernetes clusters for container orchestration.
Terraform States: Manage Terraform infrastructure states for infrastructure as code (IaC).
Terraform Modules: Manage reusable Terraform modules for efficient infrastructure management.
Google Cloud: Integration and management of Google Cloud services for cloud-based operations.
Monitor
Error Tracking: Track and manage errors in the project, facilitating quick resolution and improvement.
Alerts: Configuration and management of project alerts for real-time notifications.
Incidents: Incident management and tracking, ensuring quick response and resolution.
On-Call Schedules: Scheduling and management of on-call rotations for incident response.
Escalation Policies: Define and manage incident escalation policies for effective incident management.
Service Desk: Communication and interaction with service desk, facilitating user support and issue resolution.
Analyze
Analytics Dashboards: Create custom dashboards for project analytics, providing insights into project metrics.
Value Stream Analytics: Analyze and optimize project value streams for improved workflow efficiency.
Contributor Analytics: Analytics related to project contributors, fostering collaboration and recognition.
CI/CD Analytics: Analytics specific to CI/CD processes, including pipeline performance and efficiency.
Repository Analytics: Insights into repository activities, tracking code changes and contributions.
Code Review Analytics: Analytics related to code review processes, evaluating code quality and collaboration.
Merge Request Analytics: Analytics specific to merge requests, tracking collaboration and efficiency.
Issue Analytics: Analytics related to project issues, providing insights into issue resolution and trends.
Insights: Access project insights and data analysis, facilitating informed decision-making.
Model Experiments: Analyze and manage machine learning model experiments, providing insights into model performance.
Settings
General: General project settings, including project name, description, and visibility settings.
Integrations: Configuration settings for integrations with other tools and services.
Webhooks: Manage and configure project webhooks for external notifications and integrations.
Access Tokens: Management of project-specific access tokens for secure authentication.
Repository: Settings related to the project repository, including repository details and visibility.
Merge Requests: Configuration and settings for merge requests, including merge request approvals.
CI/CD: Configuration settings for continuous integration and deployment pipelines.
Packages and Registries: Manage and configure settings related to project packages and registries.
Monitor: Configuration and settings related to monitoring and alerting.
Analytics: Settings related to project analytics, including analytics configuration and permissions.
Usage Quotas: Monitoring and management of resource usage quotas to ensure compliance with allocated limits.
Module 1: Introduction to Version Control Systems
- 1.1 Overview of Version Control
- 1.2 Benefits of Version Control
- 1.3 Types of Version Control Systems
Module 2: Introduction to Git and GitLab
- 2.1 Understanding Git Basics
- 2.2 Introduction to GitLab
- 2.3 Setting Up GitLab Account
Module 3: Basic GitLab Operations
- 3.1 Creating a New Project
- 3.2 Cloning a Project
- 3.3 Pushing and Pulling Changes
- 3.4 Branching and Merging Basics
Working with GitLab:
Module 4: Collaborative Development
- 4.1 Forking a Project
- 4.2 Making Merge Requests
- 4.3 Reviewing Code Changes
Module 5: Issue Tracking and Project Management
- 5.1 Creating and Managing Issues
- 5.2 Milestones and Labels
- 5.3 Using Boards for Project Management
Module 6: Continuous Integration and Deployment (CI/CD)
- 6.1 Introduction to CI/CD
- 6.2 Setting Up a Simple CI/CD Pipeline
- 6.3 Customizing CI/CD Configuration
Advanced GitLab Topics:
Module 7: Advanced Branching and Merging
- 7.1 Git Flow Workflow
- 7.2 Resolving Merge Conflicts
Module 8: GitLab CI/CD in Depth
- 8.1 Advanced CI/CD Configurations
- 8.2 Multi-Stage Pipelines
- 8.3 Integrating with External CI/CD Tools
Module 9: GitLab Security Features
- 9.1 Code Quality and Code Review
- 9.2 Security Scanning (SAST, DAST)
- 9.3 Container Scanning and Dependency Scanning
Module 10: GitLab API and Automation
- 10.1 Introduction to GitLab API
- 10.2 Automation Scripts with GitLab API
Capstone Project: Real-world Application of GitLab Skills
Project: Collaborative Software Development
- Participants will work on a collaborative project, utilizing all the skills learned throughout the course. This project will include issues, branches, merge requests, and a comprehensive CI/CD pipeline.
Additional Resources and Advanced Topics:
Module 11: GitLab Geo and High Availability
- 11.1 Setting Up GitLab Geo
- 11.2 High Availability Configurations
Module 12: GitLab Pages and Wikis
- 12.1 Creating Static Websites with GitLab Pages
- 12.2 Utilizing Wikis for Documentation
Conclusion:
Final Thoughts and Next Steps
- Review of Key Concepts
- Guidance on Further Learning and Exploration
This syllabus is structured to guide participants from basic Git and GitLab concepts to advanced topics, with a focus on practical application through projects. Adjust the depth of each module based on the duration and depth of your course. Additionally, provide hands-on exercises and real-world examples to reinforce theoretical knowledge.
================================
The Git & Github Bootcamp By Colt available on Udemy
Course content
1. Welcome To The Course!
2. Join Our Community!
3. What The Course Covers
4. A Note On The Exercises
5. Accessing The Slides & Diagrams
6. What Really Matters In This Section
7. What Exactly Is Git?
8. Visualizing Git
9. A Quick History Of Git
10. Who Uses Git?
11. Git Vs. Github: What's The Difference?
12. What Really Matters In This Section
13. Installing Git: Teral Vs. GUIs
14. WINDOWS Git Installation
15. MAC Git Installation
16. Configuring Your Git Name & Email
17. Installing GitKraken (Our GUI)
18. Teral Crash Course: Introduction
19. Teral Crash Course: Navigation
20. Teral Crash Course: Creating Files & Folders
21. Teral Crash Course: Deleting Files & Folders
22. What Really Matters In This Section
23. What Is A Git Repo?
24. Our First Commands: Git Init and Git Status
25. The Mysterious .Git Folder
26. A Common Early Git Mistake
27. The Committing Workflow Overview
28. Staging Changes With Git Add
29. Finally, The Git Commit Command!
30. The Git Log Command (And More Committing)
31. Committing Exercise
32. What Really Matters In This Section
33. Navigating The Git Documentation
34. Keeping Your Commits Atomic
35. Commit Messages: Present Or Past Tense?
36. Escaping VIM & Configuring Git's Default Editor
37. A Closer Look At The Git Log Command
38. Committing With A GUI
39. Fixing Mistakes With Amend
40. Ignoring Files w/ .gitignore
41. What Really Matters In This Section
42. Introducing Branches
43. The Master Branch (Or Is It Main?)
44. What On Earth Is HEAD?
45. Viewing All Branches With Git Branch
46. Creating & Switching Branches
47. More Practice With Branching
48. Another Option: Git Checkout Vs. Git Switch
49. Switching Branches With Unstaged Changes?
50. Deleting & Renag Branches
51. How Git Stores HEAD & Branches
52. Branching Exercise
53. What Really Matters In This Section
54. An Introduction To Merging
55. Perforg A Fast Forward Merge
56. Visualizing Merges
57. Generating Merge Commits
58. Oh No! Merge Conflicts!
59. Resolving Merge Conflicts
60. Using VSCode To Resolve Conflicts
61. Merging Exercise
62. What Really Matters In This Section
63. Introducing The Git Diff Command
64. A Guide To Reading Diffs
65. Viewing Unstaged Changes
66. Viewing Working Directory Changes
67. Viewing Staged Changes
68. Diffing Specific Files
69. Comparing Changes Across Branches
70. Comparing Changes Across Commits
71. Visualizing Diffs With GUIs
72. Diff Exercise
73. What Really Matters In This Section
74. Why We Need Git Stash
75. Stashing Basics: Git Stash Save & Pop
76. Practicing With Git Stash
77. Git Stash Apply
78. Working With Multiple Stashes
79. Dropping & Clearing The Stash
80. Stashing Exercise
81. What Really Matters In This Section
82. Checking Out Old Commits
83. Re-Attaching Our Detached HEAD!
84. Referencing Commits Relative to HEAD
85. Discarding Changes With Git Checkout
86. Un-Modifying With Git Restore
87. Un-Staging Changes With Git Restore
88. Undoing Commits With Git Reset
89. Reverting Commits With...Git Revert
90. Undoing Changes Exercise
91. What Really Matters In This Section
92. What Does Github Do For Us?
93. Why You Should Use Github!
94. Cloning Github Repos With Git Clone
95. Cloning Non-Github Repos
96. Github Setup: SSH Config
97. Creating Our First Github Repo!
98. A Crash Course on Git Remotes
99. Introducing Git Push
100. Touring A Github Repo
101. Practice With Git Push
102. A Closer Look At Git Push
103. What does "git push -u" mean?
104. Another Github Workflow: Cloning First
105. Main & Master: Github Default Branches
106. Github Basics Exercise
107. What Really Matters In This Section
108. Remote Tracking Branches: WTF Are They?
109. Checking Out Remote Tracking Branches
110. Working With Remote Branches
111. Git Fetch: The Basics
112. Demonstrating Git Fetch
113. Git Pull: The Basics
114. Git Pull & Merge Conflicts
115. A Shorter Syntax For Git Pull?
116. What Really Matters In This Section
117. Github Repo Visibility: Public Vs. Private
118. Adding Github Collaborators
119. Github Collaboration Demo
120. What are READMEs?
121. A Markdown Crash Course
122. Adding a README To A Project
123. Creating Github Gists
124. Introducing Github Pages
125. Github Pages Demo
126. What Really Matters In This Section
127. The Pitfalls Of A Centralized Workflow
128. Centralized Workflow Demonstration
129. The All-Important Feature Branch Workflow
130. Feature Branch Workflow Demo
131. Merging Feature Branches
132. Introducing Pull Requests
133. Making Our First Pull Request
134. Merging Pull Requests With Conflicts
135. Configuring Branch Protection Rules
136. Introducing Forking
137. Forking Demonstration
138. The Fork & Clone Workflow
139. Fork & Clone Workflow Demonstration
140. What Really Matters In This Section
141. Why is Rebasing Scary? Is it?
142. Comparing Merging & Rebasing
143. Rebase Demo Pt 1: Setup & Merging
144. Rebasing Demo Pt 2: Actually Rebasing
145. The Golden Rule: When NOT to Rebase
146. Handling Conflicts & Rebasing
147. What Really Matters In This Section
148. Introducing Interactive Rebase
149. Rewording Commits With Interactive Rebase
150. Fixing Up & Squashing Commits With Interactive Rebase
151. Dropping Commits With Interactive Rebase
152. What Really Matters In This Section
153. The Idea Behind Git Tags
154. A Side Note On Semantic Versioning
155. Viewing & Searching Tags
156. Comparing Tags With Git Diff
157. Creating Lightweight Tags
158. Creating Annotated Tags
159. Tagging Previous Commits
160. Replacing Tags With Force
161. Deleting Tags
162. IMPORTANT: Pushing Tags
163. What Really Matters In This Section
164. Working With The Local Config File
165. Inside Git: The Refs Directory
166. Inside Git: The HEAD file
167. Inside Git: The Objects Directory
168. A Crash Course On Hashing Functions
169. Git As A Key-Value Datastore
170. Hashing With Git Hash-Object
171. Retrieving Data With Git Cat-File
172. Deep Dive Into Git Objects: Blobs
173. Deep Dive Into Git Objects: Trees
174. Deep Dive Into Git Objects: Commits
175. What Really Matters In This Section
176. Introducing Reflogs
177. The Limitations of Reflogs
178. The Git Reflog Show Command
179. Passing Reflog References Around
180. Time-Based Reflog Qualifiers
181. Rescuing Lost Commits With Reflog
182. Undoing A Rebase w/ Reflog - It's A Miracle!
183. What Matters In This Section
184. The Global Git Config File
185. Writing Our First Git Alias
186. Setting Aliases From The Command Line
187. Aliases With Arguments
188. Exploring Existing Useful Aliases Online
Master the essentials and the tricky bits: rebasing, squashing, stashing, reflogs, blobs, trees, & more!
Colt Steele is one of the leading instructors on Udemy, He is super motivated in what he is doing. His passion for teaching is why you will love this course, his passions is super contagious and you will also be passionate about Git and Github. And you will probably be addicted to his way of teaching like every one of us who love and enjoy his energy...
