5 DevOps Project- GitLab, Kubernetes ,Docker, AWS, SonarQube

Discover how to streamline automation by managing code, building, testing, and deploying applications. Leverage GitLab as a one-stop, efficient, flexible, cost-effective, and collaborative platform to achieve automation and compliance.

Explore GitLab as a self-sufficient web-based DevOps lifecycle tool that centralizes version control, CI/CD, build and deployment, code management, issue tracking, and project planning.

Explore how GitLab functions as a complete ci cd tool that automates end-to-end devops—from code integration and building to testing and deployment.

Understand how CI and CD drive DevOps by distinguishing continuous integration, continuous delivery, and continuous deployment, including packaging, manual triggers, and automatic deployment to customers.

Master single-page applications that load content dynamically without full page reloads for a fast, smooth experience. Build spa-based projects with Node.js and Python Flask, and deploy with Docker and Kubernetes.

Learn how to create a free GitLab account using a personal email, verify via email, sign in with Google, GitHub, or Bitbucket, and set up your project with a readme.

Add files to a GitLab repository by provisioning an AWS EC2 server, installing git, and generating an SSH key. Clone the project, edit files, commit, and push.

Refresh your Git knowledge by learning core commands like git init, git clone, git add, git commit, and git push to collaborate on code using GitLab and GitHub.

Learn how a GitLab pipeline file automates build, test, and deploy steps via stages and jobs, triggered by code pushes, merge requests, or scheduling for ci cd process.

Leverage GitLab's native package registry to support Maven, npm, Python, nuget, and more in a secure registry. Integrate it with CI/CD, enabling granular access control, versioning, and automated dependency management.

Master Docker basics by reviewing containers, images, and essential commands (docker ps, run, stop, rm, images, rmi) and explore underlying infrastructure agnosticism and orchestration with Kubernetes and Docker Swarm.

Explore GitLab container registry, a built-in, private and secure alternative to Docker Hub. It integrates with GitLab CI/CD for automated building, tagging, versioning, and cleanup of container images across projects.

Docker Hub serves as a registry for storing and sharing Docker images, with public and private repositories; you can login, pull, push, and search images like Ubuntu, Java, and Node.

Learn how SonarQube integrates into GitLab CI to enforce code quality and security gates, continuously monitor languages like Python, Java, and Node.js, and enable early defect detection before deployment.

Refine your Kubernetes skills to automate deployment, scaling, and management of containerized apps with kubectl commands, manifest files, and GitLab integration.

Understand how GitLab runners execute pipeline jobs, contrast shared, self-managed, and group runners, and explore self-hosted options for security, reduced wait times, and scalable customization with Docker and Kubernetes.

Explore how executors define the job environment in gitlab by selecting runners and options like shell, docker, kubernetes, and virtual machines to meet dependencies, isolation, and artifacts.

Learn to set up a self-hosted shell executor runner in AWS for GitLab, including EC2 provisioning, runner registration with tags, and ensuring Git and GitLab tools are installed.

Learn to set up a self-hosted GitLab runner on AWS EC2 with the Docker executor, install Docker, register the runner, and run pipelines using the Ubuntu latest image.

Explore how Node.js projects run on the server with JavaScript, backed by the V8 engine, and manage them with npm from init to publish, including package.json and typical folders.

Learn to run a node.js app locally on localhost by installing node and npm, building dependencies, including node_modules, and starting the server with npm start.

Set up a complete Node.js CI/CD infrastructure using GitLab managed runners, SonarQube, and an ECS cluster, including project creation and optional Docker Hub integration.

Configure a GitLab CI pipeline to build and test a Node.js project, push code from local to GitLab, and run npm install and npm test, with optional SonarQube checks.

Utilize the SonarQube stage in GitLab to analyze code quality and pass the quality gate, configuring tokens, variables, and a sonar project properties file for Node.js projects.

Create a node.js dockerfile to build a docker image for Kubernetes deployment, using node 16, copying package.json, installing dependencies, copying code, exposing port 3000, and starting with npm start.

Learn to build a docker image and push it to docker hub using gitlab ci, with docker inside docker setup, preparing for kubernetes deployment.

Create Kubernetes manifest and deployment and service yaml files for an EKS cluster, using VS Code with the Kubernetes extension, defining replicas and port 3000.

Deploy a Kubernetes application to an EKS cluster using AWS CLI and kubectl, configuring kubeconfig in GitLab, applying application.yaml, and exposing via a classic load balancer.

Explore the end-to-end Node.js project pipeline from build to deployment, including npm install, tests, vulnerability checks, docker image creation and push, and Kubernetes deployment with a load balancer.

Explore how PHP, a widely used open-source server-side scripting language, powers dynamic web applications and cross-platform projects, and learn to manage dependencies with Composer, including init, install, update, and require.

Fetch PHP code from GitHub and test it locally with a PHP server on port 8000. Install PHP, composer, and git, then clone repo and validate before dev, test, production.

Set up a PHP CI/CD infrastructure with a docker-based GitLab runner, configure a project, and deploy via an ecs cluster using the PHP docker image.

Learn to build a GitLab CI pipeline with a build, lint, and test stages using PHP 8.1 and composer images, including syntax checks and docker integration.

Create a Dockerfile for PHP using a PHP base image, set /app as workdir, install composer, copy files, install dependencies, expose port 8000, and start the PHP server for Kubernetes.

Learn to build and push Docker images in GitLab CI/CD using Docker-in-Docker, with a package stage, shared runners, and pushing to the container registry.

Explain how to create Kubernetes manifest files for a PHP site with the VS Code Kubernetes extension, including deployment and load balancer service exposing container port 8000.

Implement an end-to-end Kubernetes deployment in GitLab CI/CD to EKS using application.yaml, and the AWS CLI image, then kubectl apply -f application.yaml and verify pods.

Walk through an end-to-end php project pipeline on a docker executor, using composer, lint, and sass for security, then deploy with kubectl or AWS CLI.

Understand how to structure a python web project with flask, including app, routes, static and templates, and how run.py and requirements.txt start the app on port 5000.

Install dependencies from requirements.txt and run the Flask app locally with python3 Run.py, then explore the app structure (app, root, static, and templates) and access it at http://localhost:5000.

Set up a shell executor for Python CI/CD by provisioning an EC2 runner, installing git, docker, and kubectl, and deploying a SonarQube server for code quality checks.

Learn to build and test a Python Flask application using a GitLab CI pipeline, including installing requirements, SAS-based testing, and sonar cube testing across build, test, and sonar cube stages.

Create a docker file for a Python application using a Python base image, install dependencies from requirements.txt, copy source files, expose port 500, and start the server with python3 run.py.

Demonstrate the docker build stage and push the image to the container registry, using a shell runner and docker login with registry username and password in the pipeline.

Deploy a Kubernetes manifest to an EKS cluster by reusing deployment and service files, updating image and port, with AWS config and kubectl managed via GitLab CI/CD.

Explore an end-to-end Python DevOps workflow in GitLab, installing requirements with pip, running tests, integrating with SonarQube, and deploying via kubectl to AWS using a Dockerfile.

Discover how the GitLab agent securely connects Kubernetes clusters to GitLab, enabling GitOps with real-time observability, environment management, and scalable multi-cluster workflows.

Learn to set up a Kubernetes agent infrastructure with GitLab by creating a project, launching an EKS cluster, provisioning a server, and installing the agent and kubectl.

Connect to the Kubernetes cluster, install and register the GitLab Kubernetes agent using Helm, configure access, and verify the new namespace and running pods.

Deploy to a Kubernetes cluster using the GitLab Kubernetes agent by provisioning an EC2 runner, installing kubectl, and configuring the ci/cd pipeline.

Learn Maven commands such as clean install and clean package to build and test Java applications. Understand the Maven project structure with pom.xml, source, resources, and enterprise web app components.

Test a Java Maven-based application locally by installing Corretto 17, Maven, and Tomcat, building with mvn clean package, deploying the webapp to Tomcat's webapps, and starting the server.

Learn how to remove the application name from the URL by moving the web app to the Tomcat root, then restart the server and access it on port 8080.

Set up a Java CI/CD infrastructure with GitLab’s shared runners, images, artifact and container repositories, GitLab Kubernetes engine, then push code, create an ECS cluster, and install kubectl and helm.

Build a gitlab ci pipeline for a java project using the maven latest image to build, test, and publish war artifacts with surefire and junit reports.

Set up a Maven package registry in GitLab to store java artifacts using settings.xml, pom.xml, and token-based deployment, then publish with mvn deploy in a package stage.

Create a dockerfile for a java app on tomcat using a jdk 11 openjdk base image, remove web apps, copy the build, expose 8080, and start tomcat.

Set up a Docker build and push stage in GitLab with a Docker image and Docker service, login to the container registry, build the image, and push to the registry.

Register and connect a Kubernetes agent to a GitLab cluster, configure kube context and kubectl with AWS and helm, and ensure the Agent Java namespace is deployed and connected.

Configure a Kubernetes manifest with a deployment and a service for Tomcat app on 8080, using a container image from the registry, three replicas, and a load balancer on 80.

Deploys a Java application to AWS EKS via a Kubernetes deploy stage in GitLab, updating application.yaml with the latest image and applying kubectl to expose port 8080.

Summarizes the Java project pipeline, detailing Maven build, test, artifact management, package registry, Docker images, and deployment to a Kubernetes cluster via GitLab.

Explore auto DevOps in GitLab CI, where code from your repository is automatically detected, built, tested, scanned, and deployed via a predefined CI/CD pipeline to platforms like ECS or EKS.

Set up the infrastructure for an auto devops ci/cd project by creating an EKS cluster, a GitLab auto devops project, and an EC2 server to deploy the Kubernetes agent.

Set up the GitLab Kubernetes agent for auto devops, register it with the kube context, push code, unprotect the repository for ci/cd, and validate the agent deployment, including ecs deployment.

Install nginx ingress for auto DevOps, enabling the ingress to act as a load balancer for end-to-end Kubernetes deployments, with AWS load balancer and DNS name.

Configure auto devops by connecting GitLab to the EKS deployment, using nslookup to obtain the load balancer's external IP, and adding variables for cube context, ingress base domain, and namespace.

Enable auto DevOps to trigger a CI/CD pipeline that builds, tests, and deploys a Node.js app to production, with artifact management, code quality checks, and security scans.

Identify and fix common auto DevOps issues in GitLab, including port configurations, build path specification with Heroku dependencies, and Postgres database problems.

Learn to customize auto DevOps by supplying a custom Dockerfile, set the docker path variable in GitLab, and build, test, and deploy using your own image definition.

Customize GitLab Auto DevOps with Kubernetes files, helm charts, buildpacks, a Docker file, and ci/cd variables to enable or disable jobs and deployments.

This lecture presents a quick auto devops overview on an EKS cluster, covering ingress setup, agent configuration, and enabling GitLab CI/CD with three variables: kube context, ingress domain, and namespace.