> For the complete documentation index, see [llms.txt](https://bhushans-devops-organization.gitbook.io/advanced-projects/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://bhushans-devops-organization.gitbook.io/advanced-projects/deploying-a-youtube-clone-app-with-devsecops-and-jenkins-shared-library.md).
# Deploying a YouTube Clone App with DevSecOps and Jenkins Shared Library
## Step 1: Launch an Ubuntu 22.04 instance for Jenkins
**Log into AWS Console:** Sign in to your AWS account.
**Launch an Instance:**
Choose **"EC2"** from services. Click "Launch Instance."
**Choose an AMI:** Select an Ubuntu image.
**Choose an Instance Type:** Pick "t2.large."
**Key Pair:** Choose an existing key pair or create a new one.
**Configure Security Group:**
Create a new security group. Add rules for HTTP, and HTTPS, and open all ports for learning purposes. Add Storage: Allocate at least 20 GB of storage.
\[ opening all ports is not recommended for production environments; it's just for educational purposes. ]
**Launch Instance:** Review and launch the instance.
Access Your Instance: Use SSH to connect to your instance with the private key.
For the installation of the Jenkins follow the official Document.
{% embed url="" %}
You will need to go to your AWS EC2 Security Group and open Inbound Port 8080 since Jenkins works on Port 8080.
```
```
For unlocking the Jenkins use this command
```
sudo cat /var/lib/jenkins/secrets/initialAdminPassword
```
Jenkins Dashboard
## Step2A: Install Docker on the Jenkins machine
Run the below commands to install the docker
```
sudo apt-get update
sudo apt-get install docker.io -y
sudo usermod -aG docker $USER #my case is ubuntu
newgrp docker
sudo chmod 777 /var/run/docker.sock
```
After the docker installation, we will create a Sonarqube container (Remember to add 9000 ports in the security group).
Run this command on your EC2 instance to create a SonarQube container:
```
docker run -d --name sonar -p 9000:9000 sonarqube:lts-community
```
Now copy the IP address of the ec2 instance
```
```
Enter username and password, click on login and change password
```
username admin
password admin
```
#### SonarQube Dashboard
#### Step2B: Install Trivy on Jenkins machine
```
sudo vi trivy.sh
```
```
sudo apt-get install wget apt-transport-https gnupg lsb-release -y
wget -qO - https://aquasecurity.github.io/trivy-repo/deb/public.key | gpg --dearmor | sudo tee /usr/share/keyrings/trivy.gpg > /dev/null
echo "deb [signed-by=/usr/share/keyrings/trivy.gpg] https://aquasecurity.github.io/trivy-repo/deb $(lsb_release -sc) main" | sudo tee -a /etc/apt/sources.list.d/trivy.list
sudo apt-get update
sudo apt-get install trivy -y
```
Provide executable permissions and run the shell script
```
// Some codesudo chmod +x trivy.sh
./trivy.sh
```
This will install Trivy on our Jenkins machine.
## Step3A: Launch an Ubuntu instance for Splunk
**Step 1: Launch Instances**
1. Log in to your AWS console or your chosen cloud provider.
2. Navigate to the EC2 service and launch Ubuntu 22.04 instances. Ensure you select T2.medium as the instance type and allocate 24GB of storage to each instance.
**Step 2: Install Splunk**
At this point, the first machine is set up with Jenkins. You can now move to the second machine and proceed with the installation of Splunk.
* Connect to your second instance using Putty or Mobaxtreme.
To download and install Splunk on your Ubuntu instance use the `wget` command, use the following command.
```
wget -O splunk-9.1.1-64e843ea36b1-linux-2.6-amd64.deb "https://download.splunk.com/products/splunk/releases/9.1.1/linux/splunk-9.1.1-64e843ea36b1-linux-2.6-amd64.deb"
```
To Depackage the Splunk use the below command
```
sudo dpkg -i splunk-9.1.1-64e843ea36b1-linux-2.6-amd64.deb
```
```
sudo /opt/splunk/bin/splunk enable boot-start
```
By running this command, you ensure that Splunk Enterprise is configured to start automatically when your Ubuntu system boots, allowing you to seamlessly integrate it into your workflow.
Please note that after running this command, you should follow the on-screen prompts to accept the terms and complete the setup to 100%.
After completing the initial setup and accepting the terms, you'll be prompted to create an admin user.
**Administrator Username:** Choose a username for the admin account. This should be a unique and secure username.
**Administrator Password:** Set a strong and secure password for the admin account. It's important to choose a password that combines upper and lower-case letters, numbers, and special characters for enhanced security.
Confirm your password to ensure it matches the one you initially entered.
By creating an administrator username and password, you'll have full access to your Splunk instance, allowing you to configure and manage it effectively.
```
sudo ufw allow openSSH
sudo ufw allow 8000
sudo ufw status
sudo ufw enable
```
```
sudo /opt/splunk/bin/splunk start
```
After Installing set up the Splunk Account- For reference please check official document
## Step3B: Install the Splunk app for Jenkins
In Splunk Dashboard
Click on Apps --> Find more apps
Search for Jenkins in the Search bar
### You will get the Splunk app for Jenkins and click on install
On the homepage of Splunk, you will see Jenkins has been added
In the Splunk web interface, go to Settings > Data Inputs.
Click on HTTP Event Collector. -> Click on Global Settings
\
Set All tokens to enabled
Uncheck SSL enable
Use 8088 port and click on save
Now click on New token -> Provide a Name and click on the next
Click Review & Submit
Click Start searching
Now let's copy our token again
In the Splunk web interface, go to **Settings** > **Data Inputs**. -> Click on the HTTP event collector
Now copy your token and keep it safe
## Add Splunk Plugin in Jenkins
Go to Jenkins dashboard
Click on Manage Jenkins --> Plugins --> Available plugins
Search for Splunk and install it.
Again Click on Manage Jenkins --> System
Search for Splunk
Check to enable
HTTP input host as SPLUNK PUBLIC IP
HTTP token that you generated in Splunk
Jenkins IP and apply.
Now go to Putty or Mobaxtreme and In Splunk machine run this command
```
sudo ufw allow 8088
```
### Restart Both Splunk and Jenkins
Let's Restart our Splunk machine
Click on Settings --> Server controls
Now restart Jenkins and log in again.
```
#this will restart jenkins
```
Now go to Splunk and click on the Jenkins app and you will get this output monitoring
## Step4A: Integrate Slack for Notifications
### Create a Slack account
Open your preferred web browser (e.g., Google Chrome, Mozilla Firefox, Safari, or Microsoft Edge).
In the address bar, type or click on the following URL to access Slack's official website: [https://slack.com](https://slack.com/)
On the Slack homepage, you'll find a prominent "SIGN UP WITH GOOGLE" or "Try for Free" button. Click on it
### Add the Channel -
## **Step4B: Install the Jenkins CI app on Slack**
Go to Slack and click on your name
Select Settings and Administration
Click on Manage apps
It will open a new tab
Search for Jenkins CI and click on it
Now choose your Slack channel
Click on Add Jenkins CI integration.
You will be redirected to this page
Copy the team subdomain and integration token credential ID for later use.
* **Team subdomain:** `mrbhushan`
* **Integration token credential ID:** Create a secret text credential using `LpaDDc2n96KFOLtQ4mDqkxEQ` as the value
### Install Slack Notification Plugin in Jenkins
Go to Jenkins Dashboard
Click on manage Jenkins --> Plugins --> Available plugins
Search for Slack Notification and install
Click on Manage Jenkins --> Credentials --> Global
Select kind as Secret Text
At Secret Section Provide Your Slack integration token credential ID
Id and description are optional and create
Click on Apply and save
manage Jenkins -> add secrete credentials of slack & workspace is slack subdomain
Apply & save.
## **Step5A: Start Job**
Go to Jenkins dashboard and click on New Item.
Provide a name for the Job & click on Pipeline and click on OK.
## Step5B: Create a Jenkins shared library in GitHub
Create a new repository in GitHub named Jenkins\_shared\_library.
Connect to your VS Code
Create a directory named Jenkins-shared-library
Create a Vars directory inside it
```
echo "# Jenkins_shared_library" >> README.md
git init
git add README.md
git commit -m "first commit"
git branch -M main
# make sure to change your repo Url here
git remote add origin https://github.com/Bhushan0151/Jenkins-shared-library.git
git push -u origin main
```
Now, Let's Write a Groovy script for our Pipeline
Create a **cleanWorkspace.groovy** file and add the below code
```
#cleanWorkspace.groovy //cleans workspace
def call() {
cleanWs()
}
```
Create **checkoutGit.groovy** file and add the below code
```
def call(String gitUrl, String gitBranch) {
checkout([
$class: 'GitSCM',
branches: [[name: gitBranch]],
userRemoteConfigs: [[url: gitUrl]]
])
}
```
Now push them to GitHub using the below commands from vs code
```
git add .
git commit -m "message"
git push origin main
```
## Step5C: Add Jenkins shared library to Jenkins system
Go to Jenkins Dashboard
Click on Manage Jenkins --> system
Search for Global Pipeline Libraries and click on Add
Now Provide a name that we have to call in our pipeline
## Step5D: Run Pipeline
Go to Jenkins Dashboard again & select the job and add the below pipeline
```
@Library('Jenkins-shared-library')_ // name used in jenkins library
def COLOR_MAP = [
'FAILURE' : 'danger',
'SUCCESS' : 'good'
]
pipeline{
agent any
parameters {
choice(name: 'action', choices: 'create\ndelete', description: 'Select create or destroy.')
}
stages{
stage('clean workspace'){
steps{
cleanWorkspace()
}
}
stage('checkout from Git'){
steps{
checkoutGit('https://github.com/Bhushan0151/Youtube-clone-app.git', 'main')
}
}
}
post {
always {
echo 'Slack Notifications'
slackSend (
channel: '#jenkins', // change your channel name
color: COLOR_MAP[currentBuild.currentResult],
message: "*${currentBuild.currentResult}:* Job ${env.JOB_NAME} \n build ${env.BUILD_NUMBER} \n More info at: ${env.BUILD_URL}"
)
}
}
}
```
### **Slack Notifications-**
## **Step6**: **Install Plugins like JDK, Sonarqube Scanner, NodeJs**
### **Step6A: Install Plugin**
Goto Manage Jenkins →Plugins → Available Plugins →
Install below plugins
1 → Eclipse Temurin Installer (Install without restart)
2 → SonarQube Scanner (Install without restart)
3 → NodeJs Plugin (Install Without restart)
### **Step6B: Configure Java and Nodejs in Global Tool Configuration**
Goto Manage Jenkins → Tools → Install JDK(17) and NodeJs(16)→ Click on Apply and Save
### **Step6C: Configure Sonar Server in Manage Jenkins**
Grab the Public IP Address of your EC2 Instance, Sonarqube works on Port 9000, so \:9000.
Goto your Sonarqube Server. Click on Administration → Security → Users → Click on Tokens and Update Token → Give it a name → and click on Generate Token ->click on update Token
copy Token
Goto Jenkins Dashboard → Manage Jenkins → Credentials → Add Secret Text. It should look like this
Now, go to Dashboard → Manage Jenkins → System and Add like the below image.
Click on Apply and Save.
**The Configure System option** is used in Jenkins to configure different server
**Global Tool Configuration** is used to configure different tools that we install using Plugins
We will install a sonar scanner in the tools.
In the Sonarqube Dashboard add a quality gate also
Administration--> Configuration-->Webhooks
Click on Create
Add details
```
#in url section of quality gate
```
```
/sonarqube-webhook/
```
### Step6D: Add New stages to the pipeline
Go to vs code and create a file **sonarqubeAnalysis.groovy** & add the below code and push to Jenkins shared library GitHub Repo.
```
def call() {
withSonarQubeEnv('sonar-server') {
sh ''' $SCANNER_HOME/bin/sonar-scanner -Dsonar.projectName=Youtube1 -Dsonar.projectKey=Youtube1'''
}
}
```
Create another file for **qualityGate.groovy**
```
def call(credentialsId) {
waitForQualityGate abortPipeline: false, credentialsId: credentialsId
}
```
Create another file for **npmInstall.groovy**
```
def call() {
sh 'npm install'
}
```
Push them to the GitHub Jenkins shared library
```
git add .
git commit -m "message"
git push origin main
```
Add these stages to the pipeline now
```
// under parameters
tools{
jdk 'jdk17'
nodejs 'node16'
}
environment {
SCANNER_HOME=tool 'sonar-scanner'
}
// add in stages
stage('sonarqube Analysis'){
when { expression { params.action == 'create'}}
steps{
sonarqubeAnalysis()
}
}
stage('sonarqube QualitGate'){
when { expression { params.action == 'create'}}
steps{
script{
def credentialsId = 'Sonar-token'
qualityGate(credentialsId)
}
}
}
stage('Npm'){
when { expression { params.action == 'create'}}
steps{
npmInstall()
}
}
```
#### Build now.
To see the report, you can go to Sonarqube Server and go to Projects.
## **Step7: Install OWASP Dependency Check Plugins**
GotoDashboard → Manage Jenkins → Plugins → OWASP Dependency-Check. Click on it and install it without restart.
First, we configured the Plugin and next, we had to configure the Tool
Goto Dashboard → Manage Jenkins → Tools →
Click on Apply and Save here.
Create a file for **trivyFs.groovy**
```
def call() {
sh 'trivy fs . > trivyfs.txt'
}
```
Push to GitHub
```
git add .
git commit -m "message"
git push origin main
```
Add the below stages to the Jenkins pipeline
```
stage('Trivy file scan'){
when { expression { params.action == 'create'}}
steps{
trivyFs()
}
}
stage('OWASP FS SCAN') {
when { expression { params.action == 'create'}}
steps {
dependencyCheck additionalArguments: '--scan ./ --disableYarnAudit --disableNodeAudit', odcInstallation: 'DP-Check'
dependencyCheckPublisher pattern: '**/dependency-check-report.xml'
}
}
```
Stage with the Dependency Check steps cannot be directly used inside a shared library.
The main reason is that pipelines loaded from shared libraries have more restrictive script security by default. So the `dependencyCheck` and `dependencyCheckPublisher` steps would fail with rejected signature errors.
Build now
You will see that in status, a graph will also be generated and Vulnerabilities.
## **Step8A: Docker Image Build and Push**
We need to install the Docker tool in our system, Goto Dashboard → Manage Plugins → Available plugins → Search for Docker and install these plugins
`Docker`
`Docker Commons`
`Docker Pipeline`
`Docker API`
`docker-build-step`
and click on install without restart
Now, goto Dashboard → Manage Jenkins → Tools →
Add DockerHub Username and Password under Global Credentials
## **Step8B: Create an API key from Rapid API**
Open a new tab in the browser and search for [rapidapi.com](http://rapidapi.com/)
It will automatically provide your mail and select a mail to create an account
Account is created
Now in the search bar search for YouTube and select YouTube v3
Copy API and use it in the groovy file
docker build --build-arg REACT\_APP\_RAPID\_API\_KEY=\ -t ${imageName} .
```
3fe354f5eamsh37c7e31ef2f57c2p129f7fjsnbfdb052f67f5
```
Create a shared library file for **dockerBuild.groovy**
```
def call(String dockerHubUsername, String imageName) {
// Build the Docker image
sh "docker build --build-arg REACT_APP_RAPID_API_KEY=3fe354f5eamsh37c7e31ef2f57c2p129f7fjsnbfdb052f67f5 -t ${imageName} ."
// Tag the Docker image
sh "docker tag ${imageName} ${dockerHubUsername}/${imageName}:latest"
// Push the Docker image
withDockerRegistry([url: 'https://index.docker.io/v1/', credentialsId: 'docker']) {
sh "docker push ${dockerHubUsername}/${imageName}:latest"
}
}
```
Create another file for **trivyImage.groovy**
```
def call() {
sh 'trivy image sevenajay/youtube:latest > trivyimage.txt'
}
```
Push the above files to the GitHub shared library.
```
git add .
git commit -m "message"
git push origin main
```
Add this stage to your pipeline with parameters
```
#add inside parameter
string(name: 'DOCKER_HUB_USERNAME', defaultValue: 'bhushann11', description: 'Docker Hub Username')
string(name: 'IMAGE_NAME', defaultValue: 'youtube', description: 'Docker Image Name')
#stage
stage('Docker Build'){
when { expression { params.action == 'create'}}
steps{
script{
def dockerHubUsername = params.DOCKER_HUB_USERNAME
def imageName = params.IMAGE_NAME
dockerBuild(dockerHubUsername, imageName)
}
}
}
stage('Trivy iamge'){
when { expression { params.action == 'create'}}
steps{
trivyImage()
}
}
```
Build now with parameters
### **Step8C: Run the Docker container**
Create a new file **runContainer.groovy**
```
def call(){
sh "docker run -d --name youtube1 -p 3000:3000 sevenajay/youtube:latest"
}
```
Create Another file to remove container **removeContainer.groovy**
```
def call(){
sh 'docker stop youtube1'
sh 'docker rm youtube1'
}
```
Push them to the Shared library GitHub repo
```
git add .
git commit -m "message"
git push origin main
```
Add the below stages to the Pipeline
```
stage('Run container'){
when { expression { params.action == 'create'}}
steps{
runContainer()
}
}
stage('Remove container'){
when { expression { params.action == 'delete'}}
steps{
removeContainer()
}
}
```
Build with parameters 'create'
It will start the container
```
```
Output-
Build with parameters 'delete'
It will stop and remove the Container
## **Step9A: Kubernetes Setup**
Connect your machines to Putty or Mobaxtreme
**Take-Two Ubuntu 20.04(t2.medium) instances one for k8s master and the other one for worker.**
Install Kubectl on Jenkins machine also.
### **Step9B: Kubectl is to be installed on Jenkins**
Connect your Jenkins machine
Create a shell script file [kube.sh](http://kube.sh/)
```
sudo vi kube.sh
```
Paste the below commands
```
sudo apt update
sudo apt install curl -y
curl -LO https://dl.k8s.io/release/$(curl -L -s https://dl.k8s.io/release/stable.txt)/bin/linux/amd64/kubectl
sudo install -o root -g root -m 0755 kubectl /usr/local/bin/kubectl
kubectl version --client
```
### Step9C: K8S Master-Slave setup
**Part 1 ----------Master Node------------**
```
sudo hostnamectl set-hostname K8s-Master
exec bash
```
**----------Worker Node------------**
```
sudo hostnamectl set-hostname K8s-Worker
exec bash
```
**Part 2 ------------Both Master & Node ------------**
```
sudo apt-get update
sudo apt-get install -y docker.io
sudo usermod –aG docker Ubuntu
newgrp docker
sudo chmod 777 /var/run/docker.sock
sudo curl -s https://packages.cloud.google.com/apt/doc/apt-key.gpg | sudo apt-key add -
sudo tee /etc/apt/sources.list.d/kubernetes.list <: --token --discovery-token-ca-cert-hash
```
Copy the config file to Jenkins master or the local file manager and save it
copy it and save it in documents or another folder save it as secret-file.txt
Note: create a secret-file.txt in your file explorer save the config in it and use this at the kubernetes credential section.
Install Kubernetes Plugin, Once it's installed successfully.
goto manage Jenkins --> manage credentials --> Click on Jenkins global --> add credentials
#### **Step9D: Install Helm & Monitoring K8S using Prometheus and Grafana**
On Kubernetes Master install the helm
```
curl -fsSL -o get_helm.sh https://raw.githubusercontent.com/helm/helm/main/scripts/get-helm-3
chmod 700 get_helm.sh
./get_helm.sh
```
See the Helm version
```
helm version --client
```
Add Prometheus Helm repo
```
helm repo add prometheus-community https://prometheus-community.github.io/helm-charts
```
Create Prometheus namespace
```
kubectl create namespace prometheus
```
**Install kube-Prometheus-stack**
**Below is the command to install kube-Prometheus-stack. The helm repo kube-stack-Prometheus (formerly Prometheus-operator) comes with a Grafana deployment embedded.**
```
helm install stable prometheus-community/kube-prometheus-stack -n prometheus
```
Let's check if the Prometheus and Grafana pods are running or not
```
kubectl get pods -n prometheus
```
Now See the services
```
kubectl get svc -n prometheus
```
This confirms that Prometheus and grafana have been installed successfully using Helm.
To make Prometheus and grafana available outside the cluster, use LoadBalancer or NodePort instead of ClusterIP.
**Edit Prometheus Service**
kubectl edit svc stable-kube-prometheus-sta-prometheus -n prometheus
**Edit Grafana Service**
```
kubectl edit svc stable-grafana -n prometheus
```
Verify if the service is changed to LoadBalancer and also get the Load BalancerPorts.
```
kubectl get svc -n prometheus
```
**Access Grafana UI in the browser**
Get the external IP from the above screenshot and put it in the browser
**Create a Dashboard in Grafana**
In Grafana, we can create various kinds of dashboards as per our needs.
**How to Create Kubernetes Monitoring Dashboard?**
For creating a dashboard to monitor the cluster:
Click the '+' button on the left panel and select ‘Import’.
Enter the 15661 dashboard id under [Grafana.com](http://grafana.com/) Dashboard.
Click ‘Load’.
Select ‘Prometheus’ as the endpoint under the Prometheus data sources drop-down.
Click ‘Import’.
This will show the monitoring dashboard for all cluster nodes
**How to Create Kubernetes Cluster Monitoring Dashboard?**
For creating a dashboard to monitor the cluster:
Click the '+' button on the left panel and select ‘Import’.
Enter 3119 dashboard ID under [Grafana.com](http://grafana.com/) Dashboard.
Click ‘Load’.
Select ‘Prometheus’ as the endpoint under the Prometheus data sources drop-down.
Click ‘Import’.
This will show the monitoring dashboard for all cluster nodes
**Create a POD Monitoring Dashboard**
For creating a dashboard to monitor the cluster:
Click the '+' button on the left panel and select ‘Import’.
Enter 6417 dashboard ID under [Grafana.com](http://grafana.com/) Dashboard.
Click ‘Load’.
Select ‘Prometheus’ as the endpoint under the Prometheus data sources drop-down.
Click ‘Import’.
### **Step9E: K8S Deployment**
Let's Create a Shared Jenkins library file for K8s deploy and delete
Name **kubeDeploy.groovy**
```
def call() {
withKubeConfig(caCertificate: '', clusterName: '', contextName: '', credentialsId: 'k8s', namespace: '', restrictKubeConfigAccess: false, serverUrl: '') {
sh "kubectl apply -f deployment.yml"
}
}
```
To delete deployment
Name **kubeDelete.groovy**
```
def call() {
withKubeConfig(caCertificate: '', clusterName: '', contextName: '', credentialsId: 'k8s', namespace: '', restrictKubeConfigAccess: false, serverUrl: '') {
sh "kubectl delete -f deployment.yml"
}
}
```
Let's push them to GitHub
```
git add .
git commit -m "message"
git push origin main
```
### The final stage of the Pipeline
```
stage('Kube deploy'){
when { expression { params.action == 'create'}}
steps{
kubeDeploy()
}
}
stage('kube deleter'){
when { expression { params.action == 'delete'}}
steps{
kubeDelete()
}
}
```
Build Now with parameters 'create'
It will apply the deployment
stage view
```
kubectl get all (or)
kubectl get svc
```
```
```
### Output -
Build with parameter 'delete'
It will destroy Container and Kubernetes deployment.
Dependacy Check Result -
Slack Notifications
**Splunk**
**Grafhana -**
### **Pipeline**
```
@Library('Jenkins-shared-library')_
def COLOR_MAP = [
'FAILURE' : 'danger',
'SUCCESS' : 'good'
]
pipeline{
agent any
parameters {
choice(name: 'action', choices: 'create\ndelete', description: 'Select create or destroy.')
string(name: 'DOCKER_HUB_USERNAME', defaultValue: 'bhushann11', description: 'Docker Hub Username')
string(name: 'IMAGE_NAME', defaultValue: 'youtube', description: 'Docker Image Name')
}
// under parameters
tools{
jdk 'jdk17'
nodejs 'node16'
}
environment {
SCANNER_HOME=tool 'sonar-scanner'
}
stages{
stage('clean workspace'){
steps{
cleanWorkspace()
}
}
stage('checkout from Git'){
steps{
checkoutGit('https://github.com/Bhushan0151/Youtube-clone-app.git', 'main')
}
}
stage('sonarqube Analysis'){
when { expression { params.action == 'create'}}
steps{
sonarqubeAnalysis()
}
}
stage('sonarqube QualitGate'){
when { expression { params.action == 'create'}}
steps{
script{
def credentialsId = 'Sonar-token'
qualityGate(credentialsId)
}
}
}
stage('Npm'){
when { expression { params.action == 'create'}}
steps{
npmInstall()
}
}
stage('Trivy file scan'){
when { expression { params.action == 'create'}}
steps{
trivyFs()
}
}
stage('OWASP FS SCAN') {
when { expression { params.action == 'create'}}
steps {
dependencyCheck additionalArguments: '--scan ./ --disableYarnAudit --disableNodeAudit', odcInstallation: 'DP-Check'
dependencyCheckPublisher pattern: '**/dependency-check-report.xml'
}
}
stage('Docker Build'){
when { expression { params.action == 'create'}}
steps{
script{
def dockerHubUsername = params.DOCKER_HUB_USERNAME
def imageName = params.IMAGE_NAME
dockerBuild(dockerHubUsername, imageName)
}
}
}
stage('Trivy iamge'){
when { expression { params.action == 'create'}}
steps{
trivyImage()
}
}
stage('Run container'){
when { expression { params.action == 'create'}}
steps{
runContainer()
}
}
stage('Remove container'){
when { expression { params.action == 'delete'}}
steps{
removeContainer()
}
}
stage('Kube deploy'){
when { expression { params.action == 'create'}}
steps{
kubeDeploy()
}
}
stage('kube deleter'){
when { expression { params.action == 'delete'}}
steps{
kubeDelete()
}
}
}
post {
always {
echo 'Slack Notifications'
slackSend (
channel: '#jenkins', // change your channel name
color: COLOR_MAP[currentBuild.currentResult],
message: "*${currentBuild.currentResult}:* Job ${env.JOB_NAME} \n build ${env.BUILD_NUMBER} \n More info at: ${env.BUILD_URL}"
)
}
}
}
```
---
# Agent Instructions
This documentation is published with GitBook. GitBook is the documentation platform designed so that both humans and AI agents can read, navigate, and reason over technical content effectively. Learn more at gitbook.com.
## Querying This Documentation
If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.
Perform an HTTP GET request on the current page URL with the `ask` query parameter, and the optional `goal` query parameter:
```
GET https://bhushans-devops-organization.gitbook.io/advanced-projects/deploying-a-youtube-clone-app-with-devsecops-and-jenkins-shared-library.md?ask=&goal=
```
`ask` is the immediate question: it should be specific, self-contained, and written in natural language.
`goal` is optional and describes the broader end goal you are ultimately trying to accomplish on behalf of the user. GitBook uses it to tailor the answer towards what is most useful for that goal.
The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.
Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.