Live Classes www.qastack.

net
+92 300 1404 303
On Weekend

/Junaid Aziz /Qasim Nazir

Live Classes www.qastack.net
+92 300 1404 303
On Weekend

1-What’s CI-CD, how did you configure it, which monitoring

software you used.
Continuous Integration (CI)
Continuous Integration focuses on integrating work frequently. Each integration is automatically verified
by building the project and running automated tests against the build. This approach helps in identifying
and fixing integration errors quickly, improving software quality, and reducing the time it takes to validate
and release new software updates

Continuous Deployment vs. Continuous Delivery

Continuous Delivery (CD) extends CI by automatically deploying all code changes to a testing or staging
environment after the build stage. It ensures that the software can be deployed at any time by manually
triggering the deployment to the production environment.
Continuous Deployment goes one step further by automatically deploying every change that passes
through the pipeline to production, without human intervention. This means every successful build can be
released to customers.
Configuration of CI/CD
Configuring CI/CD involves several steps, typically including:

1. Source Control Management: Use a version control system like Git, and host it on platforms like
GitHub, GitLab, or Bitbucket.

2. Build Tool Selection: Choose appropriate tools for building the software. For example, Maven or
Gradle for Java applications, npm or Yarn for Node.js applications.

3. Testing: Integrate automated testing tools into the pipeline to run various types of tests (unit,
integration, UI tests, etc.).

4. CI/CD Platform: Select a CI/CD platform such as Jenkins, GitLab CI/CD, GitHub Actions,
CircleCI, or Travis CI. Configure the pipeline by defining the steps in a configuration file (e.g.,
.gitlab-ci.yml for GitLab CI/CD).

5. Deployment: Automate deployment to different environments (development, testing, staging,

production) using scripts, container orchestration tools (like Kubernetes), or infrastructure as code
tools (like Terraform).

6. Rollbacks: Implement strategies for easy rollback in case of failed deployments.

Monitoring Software
Monitoring is crucial in CI/CD to ensure that the software performs well in production and to quickly
identify any issues. Commonly used monitoring tools include:

Application Performance Monitoring (APM) tools like New Relic, Datadog, and Dynatrace to
monitor application performance.

/Junaid Aziz /Qasim Nazir

Live Classes www.qastack.net
+92 300 1404 303
On Weekend

Log Management tools like Splunk, ELK Stack (Elasticsearch, Logstash, Kibana), or Graylog to
aggregate and analyze logs.

Infrastructure Monitoring tools like Prometheus, Grafana, or Zabbix to monitor the health and
performance of servers and other infrastructure components.

Error Tracking tools like Sentry, Rollbar, or Bugsnag to capture and track errors.
Configuring CI/CD and integrating monitoring tools require careful planning and knowledge of the
software development process and the tools involved. The specific configurations will depend on the
project's requirements, the technologies used, and the team's preferences.

2- Explain CICD pipelines which you have followed?

1. Simple CI Pipeline
A straightforward Continuous Integration (CI) pipeline involves the following steps:

 Code Commit: Developers push code to a version control system (like Git).

 Build: The CI server monitors the repository and triggers a build for every change.
 Test: Automated tests (unit tests, integration tests) are run to ensure the code meets quality
standards.
 Merge: If tests pass, changes are merged into the main branch.

2. Basic CI/CD Pipeline

Expanding on the CI pipeline, a basic Continuous Deployment (CD) pipeline adds deployment steps:

Pre-deployment: Staging or pre-production environments are updated automatically with the new
version of the application for further testing.
Deployment: Upon successful

3. Full CI/CD Pipeline with Automated Deployments

A more advanced CI/CD pipeline includes automated deployments, often with additional quality gates:
Build & Test: Similar to the simple CI pipeline, including more comprehensive testing (like
security scanning and performance testing).
Automated Deployment to Staging: The application is automatically deployed to a staging
environment for real-world testing.
Approval: A manual approval step is included before production deployment, allowing for final
checks.

/Junaid Aziz /Qasim Nazir

Live Classes www.qastack.net
+92 300 1404 303
On Weekend

Automated Production Deployment: After approval, the application is automatically deployed to

production.
Post-Deployment Monitoring: Automated monitoring tools check the application's performance
and stability in production.

4. Multi-Stage Pipelines with Feature Flags

In complex projects, pipelines might include feature flags for managing feature releases:

Feature Branch Workflow: Developers work on features in separate branches, integrating

continuous testing.

Feature Flags: New features can be merged into the main codebase but toggled off in production
environments until ready.

Environment Promotion: Code moves through multiple environments (dev, test, staging) with
automated gates, ending in production.

Canary Releases and A/B Testing: New features are gradually rolled out to a subset of users to
test and validate before a full rollout.

5. Infrastructure as Code (IaC) and Environment Provisioning

Modern CI/CD pipelines often include IaC:

Infrastructure Provisioning: Automated scripts (using tools like Terraform or AWS

CloudFormation) define and deploy the necessary infrastructure for the application in various
environments.
Configuration Management: Tools like Ansible, Puppet, or Chef ensure configurations are
consistent across environments.

Practices and Tools

Version Control: Git, with platforms like GitHub, GitLab, or Bitbucket.
CI/CD Tools: Jenkins, GitLab CI/CD, GitHub Actions, CircleCI, Travis CI, etc.
Automated Testing: Selenium, JUnit, TestNG for application testing; SonarQube for code quality.
Monitoring and Logging: Prometheus, Grafana, ELK stack (Elasticsearch, Logstash, Kibana) for
insights into application performance and issues.
Implementing CI/CD pipelines significantly enhances the software development lifecycle, enabling faster
releases, higher quality software, and more efficient team workflows.

/Junaid Aziz /Qasim Nazir

Live Classes www.qastack.net
+92 300 1404 303
On Weekend

3- How will continues integration will happen in Jenkins

Continuous Integration (CI) in Jenkins is an automated process that allows developers to integrate code
changes into a shared repository several times a day. Jenkins automates the process of integrating, testing,
and validating code changes, making it easier to identify and fix integration errors quickly, thus improving
software quality and reducing the time to deliver it. Here's a basic overview of how Continuous Integration
can be set up in Jenkins:

1. Install Jenkins
First, you need to install Jenkins on a server. Jenkins can be installed on various operating systems,
including Linux, Windows, and macOS. You can download Jenkins from the official website and follow
the installation instructions.

2. Configure Jenkins
After installation, access Jenkins through a web browser (usually on port 8080 of the server where it's
installed, e.g., http://yourserver:8080). You'll need to perform initial setup steps, such as unlocking
Jenkins using an automatically generated password, installing suggested plugins, and creating an admin
user.

3. Create a New Job

In Jenkins, each project is configured as a "job". To set up CI, you'll start by creating a new job for your
project:
Go to the Jenkins dashboard.
Click on “New Item”.
Enter a name for your job.
Select “Freestyle project” or "Pipeline" depending on your needs.
Click “OK” to create the job.

4. Configure Source Code Management (SCM)

Within the job configuration, you'll need to specify how Jenkins should access your project's source code:
Navigate to the “Source Code Management” section.
Choose the appropriate option (e.g., Git, Subversion) and enter your repository URL.
Provide credentials if your repository is private.
Optionally, configure branches to build.

5. Configure Build Triggers

To achieve Continuous Integration, you can configure Jenkins to automatically trigger builds:
Go to the “Build Triggers” section of your job configuration.

/Junaid Aziz /Qasim Nazir

Live Classes www.qastack.net
+92 300 1404 303
On Weekend

Select “Poll SCM” to regularly check for changes in the source code repository. You can specify a
schedule using cron syntax.
Alternatively, you can use webhooks for real-time integration, allowing your SCM to notify
Jenkins of changes, which is often more efficient.

6. Configure Build Steps

Define what Jenkins should do to build your project:
In the job configuration, navigate to the “Build” section.
Click “Add build step” and choose the action Jenkins should take (e.g., executing a shell script,
building with Maven).
Configure the build step according to your project's build process.

7. Configure Post-build Actions

You can configure actions that Jenkins should take after a build:
In the job configuration, navigate to the “Post-build Actions” section.
Click “Add post-build action” to define actions such as emailing build results, archiving artifacts,
or deploying to a server.

8. Save and Run

After configuring the job, save your changes and manually trigger the first build to ensure everything is set
up correctly. If the build is successful, Jenkins will now monitor your repository for changes (based on
your build triggers) and automatically run builds, enabling Continuous Integration for your project.

9. Monitor and Adjust

Regularly monitor your Jenkins builds, adjust configurations as necessary, and optimize your CI pipeline
based on feedback and requirements.
Setting up Continuous Integration in Jenkins is a foundational step towards implementing Continuous
Delivery and Continuous Deployment, further automating the software release process.

/Junaid Aziz /Qasim Nazir