DEV Community: Warda Liaqat

Cloud 101 with AWS: From Concepts to a Real Serverless App

Warda Liaqat — Sun, 11 Jan 2026 13:57:03 +0000

Cloud computing is often introduced through definitions, diagrams, and long explanations.

But cloud really clicks when you build something real, something cool.

Recently, I delivered a Cloud 101 with AWS workshop for computer science students at UMT Lahore, with one clear goal:

No boring demos. No heavy theory. Just real cloud building.

This post is a quick reflection on the session, what we built, and why this approach worked so well.

Why "Cloud 101" Needed a Rethink

Many beginner cloud sessions still focus on spinning up virtual machines or hosting static websites. While those concepts are important, they don't reflect how modern cloud applications are built today.

Students don't just want to understand cloud, they want to use it.

So instead of starting with servers, we focused on:

Serverless computing
APIs
Managed AI services
Real-world cloud architecture

All within a 2-hour hands-on workshop.

The Big Questions We Started With

Before touching AWS, we framed the session around three simple questions:

What is cloud computing really?
Why does it matter for developers?
How do modern applications actually use cloud services?

The answers became much clearer once we started building.

What We Built in the Workshop

During the session, we built a serverless backend application using AWS services that are commonly used in real-world systems.

The stack:

AWS Lambda – to run backend logic without managing servers
Amazon API Gateway – to expose APIs over HTTP
Amazon Comprehend – to add AI-based sentiment analysis
Amazon S3 – to host a simple frontend

The frontend had two buttons:

One calling a Quote API
One calling a Sentiment Analysis API

Each button triggered a different API route, which invoked a different Lambda function.

This helped students understand routing, separation of concerns, and how services interact.

The Architecture (Big Picture)

At a high level, the flow looked like this:

This wasn't just a demo architecture, it mirrors how many real production systems are designed today.

Why This Approach Worked

This workshop format worked particularly well because:

Students didn't have to manage servers or infrastructure
Everything felt immediate and interactive
AI integration felt accessible, not intimidating, and fun at the same time
The architecture matched modern industry practices
Students walked away with something resume-worthy

Many participants were surprised by how little code was required to build a functional cloud-backed application.

Learning Beyond the Workshop

To help students continue learning after the session, I've shared the complete project code on GitHub, including:

Python Lambda functions
API Gateway route structure
Frontend example
Setup and cleanup guidance

👉 GitHub repository: cloud-101-aws-serverless-ai

Final Thoughts

Cloud is not just a technology, it's an enabler.

For students and early-career developers, my biggest advice is simple:
Build small, build often, and don't be afraid to experiment.

Cloud doesn't have to be overwhelming.

With the right starting point, it becomes empowering.

If you're interested in similar workshops or hands-on cloud learning, feel free to connect with me.

Thanks for reading ☁️

Building the Name Match Memory Game: My Experience with Amazon Q CLI

Warda Liaqat — Sun, 15 Jun 2025 18:08:21 +0000

Introduction

Have you ever been at a networking event, recognized someone's face, but completely blanked on their name? It's happened to all of us! This common social challenge inspired me to build the Name Match Memory Game a simple but effective tool to help people practice connecting faces with names.

The idea was straightforward: create a game that shows users face images, presents multiple name options, and helps them practice making the right connections. What started as a simple command-line tool evolved into a full-fledged web application, all with the help of Amazon Q CLI.

Setting Up Amazon Q CLI

Getting started with Amazon Q CLI on my Windows machine using WSL (Windows Subsystem for Linux) took a bit of setup, but was worth the effort.

First, I needed to install the AWS CLI and configure it with my credentials:

curl "https://awscli.amazonaws.com/awscli-exe-linux-x86_64.zip" -o "awscliv2.zip"
unzip awscliv2.zip
sudo ./aws/install
aws configure

Then I installed Amazon Q CLI:

curl -Lo "/tmp/q-cli.deb" "https://d3op2l77j7wnti.cloudfront.net/releases/amazon-q-cli/v0.1.0/amazon-q-cli_0.1.0_amd64.deb"
sudo dpkg -i /tmp/q-cli.deb

I faced a couple of challenges during setup:

Getting the shell initialization right (needed to add Q CLI to my PATH)
Understanding the correct commands to start a chat session
Ensuring my AWS credentials were properly configured

After some troubleshooting, I was able to start Q CLI with a simple command:

q chat

Using Q CLI to Build the Game

Once I had Q CLI running, the development process was surprisingly smooth. I started by describing my game idea:

Create a Python CLI game that helps users remember people's names and faces.

Q CLI immediately understood what I wanted and helped me design the core game logic. We started with a command-line version that:

Stored people's data in a JSON file
Displayed "faces" (as file paths in the CLI version)
Presented multiple-choice name options
Tracked correct/incorrect answers

Here's a snippet of the initial game logic Q CLI helped me create:

def play_game(self, num_rounds: int = 5) -> None:
    """Play the name matching game with multiple choice options."""
    if len(self.people_data) < 4:
        print("You need at least 4 people in the database to play the game.")
        return

    num_rounds = min(num_rounds, len(self.people_data))
    score = 0

    # Select people for this game session
    sorted_people = sorted(self.people_data, key=lambda x: x["times_shown"])
    game_people = sorted_people[:num_rounds]

    for round_num, person in enumerate(game_people, 1):
        # Generate options (3-4 name choices)
        options = [person["name"]]
        other_names = [p["name"] for p in self.people_data if p["name"] != person["name"]]
        options.extend(random.sample(other_names, min(3, len(other_names))))
        random.shuffle(options)

        # Display options and get answer
        # ...

After testing the CLI version, I asked Q CLI to help me convert it to a web application using Flask. This was where Q CLI really shined—it generated the complete Flask application structure, HTML templates, and even CSS styling.

Game Features

The final web-based game includes several key features:

1. Interactive Start Page

Q CLI helped me create an engaging start page with:

A gradient background
Preview of random faces from the database
Clear game instructions
Animated "Start Playing" button

2. Game Mechanics

Random Face Selection: Each round shows a different face
Multiple Choice: 3-4 name options as radio buttons
Immediate Feedback: Users learn right away if they were correct
Score Tracking: Progress is shown throughout the 5-round game
Final Results: Accuracy and performance summary at the end

3. Data Management

The game uses two simple JSON files:

people_data.json: Stores person information with IDs and names
game_stats.json: Tracks game statistics across sessions

// Example people_data.json
[
  {
    "id": "alice",
    "name": "Alice Johnson"
  },
  {
    "id": "bob",
    "name": "Bob Smith"
  }
]

4. Image Handling

Images are stored in the static/images/ directory and named according to person IDs (e.g., alice.jpg). The Flask application dynamically loads these images during gameplay.

Running the Game

Getting the game running required a few steps:

Prerequisites

Python 3.6+
Flask
Virtual environment

Setup Process

I created a virtual environment and installed Flask:

python3 -m venv venv
source venv/bin/activate
pip install flask

This was another area where I faced challenges—initially getting a ModuleNotFoundError: No module named 'flask' error. Q CLI helped me troubleshoot this by explaining I needed to install Flask in my virtual environment.

Starting the Game

Once everything was set up, starting the game was simple:

python app.py

Then I could access the game by opening a browser and navigating to:

http://127.0.0.1:5000/

Adding New People

To add new people to the game:

Add their information to people_data.json with a unique ID
Place their image in static/images/ with the filename matching their ID

My Learnings and Reflections

Working with Amazon Q CLI to build this game taught me several valuable lessons:

AI-assisted coding is powerful: Q CLI helped me go from concept to working application much faster than I could have alone. It understood my requirements and generated well-structured code.
Interactive problem-solving: When I hit roadblocks (like Flask installation issues), Q CLI provided clear, step-by-step solutions.
Learning by doing: The conversational nature of Q CLI allowed me to learn Flask web development concepts as we built the application together.
Iterative development: I could easily request changes or enhancements, like adding the start page, and Q CLI would help implement them.

What I enjoyed most was how Q CLI maintained context throughout our conversation. It remembered what we had built earlier and could refer back to previous code when making improvements.

What's Next?

This project is just the beginning! With the foundation in place, I'm planning several enhancements:

User Authentication: Allow multiple users to track their individual progress
Upload Interface: Web form to add new people and images directly
Database Integration: Replace JSON files with a proper database
Leaderboard: Compare performance with other users
Difficulty Levels: Add timed challenges and harder modes
Mobile Optimization: Make the game fully responsive for on-the-go practice

Conclusion

Building the Name Match Memory Game with Amazon Q CLI was both educational and enjoyable. The tool helped me transform a simple idea into a functional web application, even as someone relatively new to Flask development.

If you have a project idea but aren't sure how to implement it, I highly recommend giving Amazon Q CLI a try. The interactive, conversational approach to coding makes development more accessible and helps bridge knowledge gaps as you build.

Have you used Amazon Q CLI for any of your projects? I'd love to hear about your experiences in the comments!

Ready to improve your name-face memory?

Check out the GitHub repository to try the game yourself!

Revolutionize Your AWS App Development: AWS Application Composer and Our Helpdesk Project

Warda Liaqat — Wed, 31 Jan 2024 17:38:58 +0000

Introduction

On November 30, 2023, Amazon Web Services (AWS) unveiled a groundbreaking enhancement to its development toolkit – the general availability of AWS Application Composer in Visual Studio Code (VS Code). This integration brings forth a powerful Integrated Development Environment (IDE) extension, empowering developers to streamline and expedite the application development lifecycle. In this article, we will explore the features and benefits of the AWS Application Composer IDE extension, how we utilized it in our Helpdesk project and delve into real-world scenarios where it can significantly enhance the development process.

Visual Studio Code: Install AWS Application Composer Extension

Getting Started:

To start leveraging the AWS Application Composer IDE extension, developers can access it through the AWS Toolkit for Visual Studio Code.

Pre-requisites:

VS code and it's version should be 1.7.3 or later

If VS code is not installed then please Install it's latest version from VS code website:

Download Visual Studio Code - Mac, Linux, Windows

Visual Studio Code is free and available on your favorite platform - Linux, macOS, and Windows. Download Visual Studio Code to experience a redefined code editor, optimized for building and debugging modern web and cloud applications.

code.visualstudio.com

If you already running the VS code then make sure to check the version before installing the AWS tool kit.

C:\Users\warda.liaqat>code --version
1.85.2
8b3775030ed1a69b13e4f4c628c612102e30a681
x64

C:\Users\warda.liaqat>code --help
Visual Studio Code 1.85.2
Usage: code.exe [options][paths...]

If it’s less than 1.7.3 then please upgrade it to the latest version.

Install the AWS toolkit from Visual Studio Marketplace:

AWS Toolkit from Visual Studio Marketplace

Install the AWS toolkit directly from VS code Extensions page:

How to get started with AWS Application composer in VS Code?

Options to sign in to AWS tool kit:

You need to login either with AWS Builder ID or SSO(single sign-on). And that’s it. You have it.

For further details on the authentication methods, Please have a look at:

docs.aws.amazon.com

Access Application Composer from the Toolkit for VS Code

Application Composer can be accessed through various avenues

1. VS Code Command Palette:
Open the VS Code Command Palette and navigate to Application Composer for quick and direct access.
Use CTRL+SHIFT+P to open the AWS Application Composer extension in VS code

2. Context Menu:
Right-click on your AWS CloudFormation or AWS SAM template to reveal a context menu, where you can conveniently access Application Composer.

3. AWS CloudFormation or AWS SAM Template:
Select the Application Composer button directly within any AWS CloudFormation or AWS SAM template.

Overview of us utilizing AWS Application Composer in VS Code for our Helpdesk Project

Integration with AWS Services

1. Seamless Integration:
Utilizing AWS Application Composer, we seamlessly integrated AWS services into our AP Helpdesk project. Dragging AWS service components directly onto our visual canvas, we effortlessly connected EKS, EFS, RDS, and other vital services to their corresponding sections within our Drupal application:

Advantages Realized: This approach simplified the integration process, eliminating potential hurdles and offering a visually intuitive experience for our developers. The result was a harmonious fusion of our application with AWS services, ensuring optimal performance and scalability.

Syncing Prototypes with Development Environment

2. Prototype Synchronization:
AWS Application Composer's push-button sync feature became our secret weapon for bridging the gap between prototyping and development. We used the tool to synchronize prototypes, ensuring that changes made during the prototyping phase seamlessly translated into our actual development environment.

Note: In order to do the sync you must be authenticated to AWS with your IAM credentials. For more details please visit:

docs.aws.amazon.com

Smooth Development Cycles

This streamlined transition from prototyping to development minimized discrepancies and expedited our development cycles. The push-button sync feature became a catalyst for maintaining consistency and accelerating the implementation of new features.

Real-World Scenarios

Scenario 1:
Rapid Prototyping for a New Feature: Consider a scenario where a development team needs to prototype a new feature for an existing application. With AWS Application Composer in VS Code, developers can rapidly create a prototype by visually designing the new feature's architecture. The generative AI code suggestions provide a head start, allowing the team to quickly iterate and fine-tune the prototype before integrating it into the main application.

Scenario 2:
Infrastructure Changes and Visual Debugging: In a scenario where an application undergoes significant infrastructure changes, developers can leverage Application Composer to visually debug and validate the alterations. The drag-and-drop interface simplifies the process of modifying the architecture, while the real-time visualization helps identify any potential issues or misconfigurations before deployment.

Conclusion:

Introducing AWS Application Composer in Visual Studio Code—a game-changer for application development. Its drag-and-drop interface, seamless AWS integration, and AI code suggestions streamline development, addressing common challenges. In our AP Helpdesk project, Application Composer became our guiding force, bringing architectural vision to life with visualizations and prototype synchronization. This tool is a testament to transformative power, setting a precedent for how we approach AWS application development—blending visual artistry and robust functionality for unparalleled success.

References:

AWS Blog
AWS Docs
AWS What's New - IDE Extension AWS Application Composer
Application Composer - AWS Website

Do share your feedback and do Follow me on LinkedIn and Facebook:

LinkedIn
Facebook

Cheers, Happy Clouding and Articling!

CI/CD Pipeline Hands-on | AWS Code Pipeline, Elastic Beanstalk, GitHub

Warda Liaqat — Sun, 21 Aug 2022 11:31:33 +0000

Introduction

In this article we are going to see how to use AWS code pipeline to set up a a very simple CI/CD pipeline for your developments with three products:

AWS Code Pipeline
Elastic Beanstalk (EB)
GitHub

I already have written some article covering each and everything about CI/CD, Do have a look to previous articles to have a better understanding of this one.

Intro to AWS Code pipeline

AWS Code Pipeline is a fully managed continuous delivery service that helps you automate your release pipelines for fast and reliable application and infrastructure updates. Code Pipeline automates the build, test, and deploy phases of your release process every time there is a code change, based on the release model you define. This enables you to rapidly and reliably deliver features and updates. You can easily integrate AWS Code Pipeline with third-party services such as GitHub or with your own custom plugin. With AWS Code Pipeline, you only pay for what you use. There are no upfront fees or long-term commitments.

Architecture of Our Code Pipeline

We are going to deploy a code pipeline on AWS. Below is architecture of our pipeline

We will be using sample node.js application located in the GitHub Repo.
Setup a pipeline so, whenever we commit any changes to our code in GitHub it will trigger AWS code pipeline instance to kick-in and start deployment process
Finally code pipeline will deploy our application to our target Web Server which will be setup in AWS Elastic Beanstalk which essentially means our code will live on EC2 instances behind the scene.

So, that's it very simple one stage pipeline.

Go to GitHub and host your application there.

Let’s start building our Pipeline

Environment Setup

Go to elastic beanstalk

In a nutshell Elastic Beanstalk is just a way to deploy our resources to AWS. In this case it's gonna deploy resources to EC2 instances behind the scene. if this were a great prod application i may directly go to ec2 and set it up directly there just to have a little bit of more control but at the expense of little bit of control it allows us to deploy very quickly.
You will be landed to this page. Just click on Get started/create application

Name your application
Choose platform
I’ll go with the sample code. I’m not gonna upload our code because I want our pipeline to do it for us.
Click on create Application

It will take several minutes to create and you can see all the logs to get to know what’s happening.

It will be deployed successfully after some time with health status OK. It has also deployed sample application into that as well. We used ec2, s3 behind this but you really don’t look at that, we can see in the logs. Elastic beanstalk take care of provisioning of those resources for us.
One more thing you don’t need to install any package for your application, if Elastic beanstalk detects any package in our application it will automatically install for us. Everything about this process is very automatic where the convenience factor comes in.
So, just for the test if it’s working. EB gives us a URL at the top to test your running application

And there we go, our first application is running and our very first deployment was successful.

Set up Pipeline

Next step is to go to AWS pipeline and setup a pipeline for our application.
Go to the code pipeline from AWS management console.

Now go ahead and click on create pipeline.
You will see 5 stages to complete in order to create your pipeline.
Step 1
Choose pipeline settings
Step 2
Add source stage
Step 3
Add build stage
Step 4
Add deploy stage
Step 5
Review

Let's explore all 5 steps.

Step 1:

Just name your pipeline and leave all the settings as it is.
And click on next

Step 2

Detect option this is saying how you want to trigger your pipeline. Go with the default for better ease. Because default one is more event driven model.

Version 1:

Version 2:

Step 3

Build stage is optional so, we are going to skip it for this project.

Step 4

Deploy provider is elastic beanstalk which is our target.

Step 5

Then just review everything and click on create pipeline.
Now we can see pipeline has been created and now it’s deploying to elastic beanstalk.

It will take minute or two then we can verify if it’s been deployed.
Now go to EB by clicking the URL

You will see your app is running in browser

Testing Our Code Pipeline

Now let’s do some updates in your code from GitHub and see if our pipeline detect those changes and populate them automatically to our application that is running on Elastic Beanstalk.
You can update and commit your changes from directly GitHub or you can do it also by cloning your repo, updating your changes and them committing them locally.

Update changes in code from GitHub:

Update changes in code locally & then commit to online repo:

After updating your changes in code either from GitHub or Locally, when you'll go to your code pipeline you will observe that your pipeline is in action, It will detect changes and then update the source and will deploy changes to EB automatically.

When you observe that pipeline is successfully done then if you open/refresh the URL of your application in the browser you will observe that changes have been deployed successfully.

Conclusion

See, how code pipeline can make things easy for you when you are working on your development projects, now you don't have to manually write test cases after each change and update those changes manually. Code pipeline will handle all of that automatically for you. Now you just need to relax and focus on adding more new features to your application and do lots of advancements.

> Let me know what do you think about it or if you are already using Code Pipeline for your developments?

Connect with me:

LinkedIn
Instagram
Twitter

Getting intimate with CI/CD and CI/CD Pipeline

Warda Liaqat — Mon, 13 Jun 2022 09:19:17 +0000

Introduction:

In my previous article Why CI/CD? How was a life without CI/CD & how is it now? I talked about the Why of CI/CD. If you read that, got the concept and wanna hear more about CI/CD then In this article we are going to ding more into the concepts of CI/CD.

So,

What is CI/CD?

CI/CD is simply a method to frequently deliver apps to customers by introducing automation into the stages of app development. The main concepts attributed to CI/CD are continuous integration, continuous delivery, and continuous deployment.

CI/CD is a solution to the problems integrating new code can cause for development and operations teams (AKA "integration hell").

Specifically, CI/CD introduces ongoing automation and continuous monitoring throughout the lifecycle of apps, from integration and testing phases to delivery and deployment.

So, there are three terms:

Continuous Integration
Continuous Delivery
Continuous Deployment

Let's look into them one by one

Continuous Integration

Continuous Integration (CI) is a development practice that requires developers to integrate code into a shared repository several times a day. Each check-in is then verified by an automated build, allowing teams to detect problems early.

When you have a team of developers, each of whom is responsible for a separate feature, you need to integrate the different features before you’re ready for a release. By integrating so frequently, your team can surface errors earlier. And when those are caught, the amount of backtracking needed to find the cause is also much reduced. Therefore, your team can resolve the integration errors much faster.

Continuous Integration doesn’t get rid of bugs, but it does make them dramatically easier to find and remove
— Martin Fowler, Chief Scientist, ThoughtWorks

How to Practice Continuous Integration

If you want to practice CI, the steps roughly go like this:

Developers check out code from the repository to work on it locally. Ideally, they create a new branch for the feature they want to implement.
When their feature branch is ready, they run tests locally in their development environments.
Once all tests pass, they push the commits to the single source repository.
Whenever there are changes on the repository, a CI server checks out the changes and performs a “build and test.” A build and test is when the CI server builds the entire system on the developer’s feature branch and runs all the unit and integration tests.
The CI server notifies the team of the integration result. There should generally be four outcomes: failed build, successful build, failed tests, successful tests.
If there’s a failure, the team fixes the issue ASAP.
When the feature branch is merged to the main branch, they repeat steps 2–6.
They continue to develop and repeat the steps 2–6 whenever there’s new code to be checked in to the repository.

There are minor variations of the steps, depending on the tools you chose and the processes you agree upon within the team. **The main principles of CI** are that you:

Check in code in frequently.
Automate the build and test portion.
Always test the code locally before checking it in.
Never merge any failed branches to the main branch.
Return its status back to successful if you’re the developer who causes the failed build or test.
Make it your top priority to do so once the fail happens.

Continuous Deployment (CD)

Continuous Deployment is closely related to Continuous Integration and refers to the release into production of software that passes the automated tests.

So why do you need to care about continuous deployment as part of your development process? Well, when there are releases, there will be deployment steps. These deployment steps tend to repeat for each release. Instead of performing the deployment manually for each release, why not have the deployment steps be executed automatically? Of course, ideally, this code has been built and tested successfully by the CI server too.

Essentially, it is the practice of releasing every good build to users

SO, What’s the Difference Between Continuous Deployment and Continuous Delivery? Aren't they same thing?

You may be confused by the fact that there’s another term CD can stand for: continuous delivery. So what’s the difference between the two?

According to Jez Humble, continuous deployment is about automating the release of a good build to the production environment. In fact, Humble thinks it might be more accurate to call it “continuous release.” On the other hand, continuous delivery is about ensuring that every good build is potentially ready for production release. At the very least, it’s sent to the user acceptance test (UAT) environment. Your business team can then decide when a successful build in UAT can be deployed to production and they can do so at the push of a button.

Sometimes it’s unwise to have every build be an actual release. Such is the case with embedded software. So we need a slightly different definition for builds that potentially can be releases but need not be automatically deployed—hence the existence of “continuous delivery.”

To keep it simple, here’s a diagram.

When you’ve successfully implemented continuous deployment, it implies that continuous delivery is achieved as well. But the converse isn’t true.

The term “continuous deployment” came before the term “continuous delivery.” However, do note that in most enterprise setups, the business side of the company prefers to manually trigger the deployment. So, chances are your organization will actually be implementing continuous delivery, which is a good enough solution.

Now let's move onto the concept of CI/CD Pipeline

Now that we have understood the concepts of CI and CD, it’s time we get more into the weeds of what a CI/CD pipeline is.

A CI/CD pipeline can be easily understood as the process pathway through which we can deliver a single unit of production-ready software. Your team will choose which services they’ll use to build this; there’s no single canonical implementation of a CI/CD pipeline.
The simplest version of the pipeline can best be described by this activity chain:

Each of these steps in the activity chain can be handled by a single service or piece of software. Alternatively, you can split the tasks into several different tools.

CI/CD Pipeline Phases

While each stage of a CI/CD pipeline may be performed manually, the actual benefit of CI/CD pipelines is achieved via automated processes. A CI/CD pipeline is made up of discrete subgroups of operations which are organized into pipeline phases.

Following are some common pipeline phases:
Source
The source contains the initial source code repository and any change in the code triggers CI/CD tools to automatically apply modifications. User-initiated processes, programmed timelines, and the outcomes of other pipelines are other typical triggers. The process begins with a Push-request, written manually, which causes the development of Webhooks to run the pipeline.

Build
At this stage complies an app with its source code repository. But, in fact, the build stage is not necessarily used for such languages as Python, JavaScript, and Ruby. Inability to pass the build phase indicates a basic project malfunction, which should be addressed as soon as possible.

Test
The implementation of automated tests to check the validity of code and the functionality of the program is included in the test phase. This stage’s automation facilitates the quality assurance for the running code. Testing eliminates potentially repeatable issues from making their way to the customers. Besides, here happens the Merge stage, which is responsible for the finalization of the assessment, needed before the release to the source code repository.

Deploy
This is the last step of the CI/CD pipeline, and it’s done if the previous testing and merging go without conflicts and errors. Deployment means your code goes to the servers, like Azure or AWS to make it functional.

Example of a CI/CD Pipeline Toolchain

To better illustrate a pipeline, I’ll conjure up a fictional example involving an enterprise web software written in Java. Suppose I want to start from scratch and I want to keep things easy. I’d make the following choices:

Source code control: I’ll host the code on GitHub (hosted service) as a private repository. This way, I can use its integrations with major software and services to establish triggers whenever code commits are checked in.

Continuous integration: I’ll get CircleCI and connect it with GitHub integrations. This allows every code commit to notify CircleCI via webhooks. When code changes notify CircleCI, it will then pull the code from the GitHub repository and proceed to build and run the tests. Any failures or successes can be sent by email or Slack notification.

Deploy to UAT: Suppose my UAT is running on a server in AWS ECS. I’ll configure CircleCI to deploy automatically to the AWS UAT server when the build and tests are successful.

Deploy to Production: For deployment to production, I’ll reuse the integration steps for deploying to UAT.
With sufficient configuration at the start and by employing three major services, I’ve designed a good enough CI/CD pipeline.

CI/CD pipeline principles and best practices

There are no ironclad rules that define the best ways to create CI/CD pipelines. However, there are certain guidelines to follow while building these pipelines.

If the build is broken, fix it immediately. Teams should drop any work if the changes introduced break the pipeline.
Shift left in testing. If the team has a large number of tests, first run fundamental and faster tests such as code quality.
Use a consistent environment. An application deployed to a handcrafted environment is most likely to fail when it hits the production environment.
Bake in code quality checks. You can easily integrate many open source tools into the CI/CD pipeline to provide comprehensible documentation for developers.
Gauge your CI/CD pipeline's speed. How long does the build sit in queue before it's picked up by an agent? How long does it take to provision a new pipeline for an application? As a general rule of thumb, if it takes longer than grabbing a coffee to build, test and deploy the changes, that's a signal that the pipeline is not providing fast feedback.
Document everything. Describe how the pipeline functions. If something fails and there is documentation around how the pipeline works developers can attempt to fix the issues by reading the pipeline documentation and issuing pull requests. This enhances collaboration across teams as well.

Overall considerations to build a CI/CD pipeline

CI/CD pipelines aim to streamline software development and delivery, but real-world implementations can widely differ from the theoretical concepts. Organizations have specific problems to tackle, resources to draw upon and technology decisions to weigh.

Consider investments in time and resources to manage the infrastructure that supports CI/CD pipelines. On-premises repos and version control such as Git, along with build servers such as Jenkins, require a lot of effort to patch and maintain.

If a team chooses to run the CI/CD pipelines with hosted providers, such as GitHub and Azure DevOps, there are additional considerations. A CI/CD pipeline in the cloud typically deploys the application as a hosted workload on that cloud's platform and will require the team to assign underlying infrastructure resources (IaaS, PaaS or SaaS).

There are also many security questions to answer with CI/CD in the cloud. How do you authenticate users and grant them appropriate access to resources? How does the provider store credentials or service connection strings to access outside resources? How do CI/CD pipelines with a cloud provider access internal resources if required? Many providers allow organizations to run the hosted agent in their internal network, but this requires outbound connections to allow egress traffic, which may require a security review and exception.

There is no one-size-fits-all answer to implementing a CI/CD pipeline. However, there are common attributes and CI/CD best practices that can help you design, implement and continuously improve your software delivery process. Start with very basic pipelines and then continuously gather feedback and improve them over time.

Now you can tell others that:

Connect with me:

LinkedIn
Instagram
Twitter

References:

https://incora.software/insights/what-is-the-role-of-ci-cd-pipeline-in-software-development/75
https://www.redhat.com/en/topics/devops/what-is-ci-cd
https://www.plutora.com/blog/understanding-ci-cd-pipeline
https://www.techtarget.com/searchsoftwarequality/CI-CD-pipelines-explained-Everything-you-need-to-know
https://www.techtarget.com/searchitoperations/tip/How-to-build-a-CI-CD-pipeline-with-examples

Why CI/CD? How was a life without CI/CD & how is it now?

Warda Liaqat — Mon, 16 May 2022 14:58:10 +0000

Introduction:

I'm planning to publish a series of article on CI/CD including the CI/CD basics, life with CI/CD, why CI/CD is important, how to implement CI/CD, and a guided tutorial to help you create your own pipeline. In this write-up, I will cover CI/CD basics, life with CI/CD and how is it now.

An overview to CI/CD

As a software developer what would you like to achieve with your development? Obviously a timely delivery of your product or put simply, early time to market.

Speed is the key to modern software development. All traditional waterfall software development has largely been replaced by rapid iterative techniques that support development and release. These techniques go by several names, including continuous integration, continuous delivery, and continuous deployment.

Even though each technique has slight differences, the importance placed on continuous iteration has drastically altered the way software is developed. By reducing risk and cost, businesses can quickly get products to market and refine them over time in a cost-effective manner.

In addition, such iterations require well-designed and active development pipelines that support multiple staged iterations simultaneously and keep entire development teams busy.
Once a build is deployed, the next build undergoes testing, while the very latest build is being coded.

Life Without Devops/CICD:

Let's take an example and look at a life of developers who aren't using CI/CD as SDLC.

e.g., There's a team comprise of 10 members and each is given a model to work on for app development. After development they generate a zip file and upload to aws environment manually and then while testing the environment they detect a bug and to address it they decide to write a test case. They wrote a test case and then executed it manually. It's done and again they generate a zip file and upload to aws environment manually and again while testing the environment they detect a bug and cycle keep on continue. You can see it's such a manual and slow processwhich a developer feel and some of them what they do, they skip writing test cases and test cases never get executed to. so, the developers feeling helpless, productivity also reduces so, see how the life has become for developer.

Life With Devops/CICD:

Now let's switch to the life of developer with DevOps. Developer push the code to source control service and there are automated build and test phases and then deployment also happen very easily. Now the life of developer is eased up right.

Why CI/CD?

Both CI and CD form the backbone of the modern DevOps environment. You can think of CI/CD processes as like a software development lifecycle.

The concept of CI/CD enables enterprises to ship software quickly and effectively. By implementing CI/CD, products can reach the market faster than ever before, releasing code continuously into production, and ensuring bugfixes and new features are released using the most effective delivery system.

Extends beyond test automation.
A quality assurance engineer writes, executes and automates various sorts of tests to inform development teams whether a software build succeeds or fails using automated testing frameworks. During each sprint, functionality tests are created and combined into an application-wide regression test. I am sure you can see that this goes far beyond the above mentioned testing, but as a fast and convenient solution of automated processes.

Allows deploying code frequently.
For enterprises that wish to upgrade their apps on a regular basis and demand a reliable delivery method, CI/CD pipelines are the best option. Production is the process of organizing builds, performing tests, and automating deployments in order to distribute code changes. As soon as it is established, a team can focus more on improving apps rather than the technical details of transporting them to computing environments. The result may be that developers are now more likely to push updates.

Enables to get the continuous improvement.
Continuous integration and continuous delivery is a never-ending cycle of development, testing, and deployment. When code is tested, developers can respond quickly to feedback and upgrade the code as needed. Each member of the team is capable of changing code and solving any issues that may arise. Due to the fact that this cycle can continue infinitely, developers can improve the original code in the most efficient manner possible.

Reduces time to deployment.
CI/CD pipelines allow for substantially faster time to market for new product features, which leads to happier customers and less burden on development.

DevOps service providers:

Among the most used and popular DevOps services, namely Amazon Web Services, Azure DevOps services, and Google Cloud services, there is a battle going on in the market. Based on Statista analytics, Amazon Web Services, the most prominent provider in the cloud computing industry, held 32% of the total market in the 3rd quarter of 2021. Microsoft Azure comes in 2nd place with a 21% market share, followed by Google Cloud with an 8%. Therefore, in the 3rd quarter of 2021, these three cloud suppliers are undoubtedly leading within the statistics.

Wanna hear more? Just wait for my next write up on this topic... Till then Happy learning & Clouding!

Connect with me:

LinkedIn
Instagram
Twitter

Working with Git Branches!

Warda Liaqat — Mon, 25 Apr 2022 10:26:29 +0000

Git Branches are quite handy when you are working on large projects and collaborating in teams. So, I just wanted to explore and share my thoughts/findings on it.
I have had two article on basics and getting started with Git & GitHub. Have a look below:

Using GitHub we usually deal with three types of Branches:

Master Branch
Feature branch
Hot Fix Branch

Master Branch

Master branch is the naming convention for the main or default branch, all your code and commits will be in that branch

Feature branch

At first the code at master and feature branch will be the same but when we make updates to feature branch those changes will only be seen into feature branch.

Useful: it is useful if you are working on new features of app and you want a kind of sandbox area to work on your code, test it, make it correct and merge into main branch so, you can't affect the functionalities of main app.

Hot Fix Branch

This branching type/method is useful if you have many people working on a same repository and lots of branches going on at once. one very common thing that you will see in dev. is that let's see you will be working on this feature branch for 4 weeks or more and you have all those changes that you have made and then you find out there's this major bug that you have to fix real quick. then we made a new branch called Hot Fix Branch, you can see I made the change in one commit to fix whatever bug was wrong with the code and make sure it's working correctly and then merge back to master branch.

I hope you have found this article helpful in some way.

If you have any comments, do let me know!

Connect with me:

LinkedIn
Instagram
Twitter

GitHub VS Local Git Workflow

Warda Liaqat — Fri, 22 Apr 2022 15:50:25 +0000

I have had three article on basics, getting started and branches in Git & GitHub. Have a look below:

We observe a significant difference between Local Git and GitHub workflows. To illustrate my point, I made a comparison.

Let me know what do you think about it????

Connect with me:

LinkedIn
Instagram
Twitter

Get your way started towards Git & GitHub!

Warda Liaqat — Tue, 19 Apr 2022 10:51:58 +0000

In my previous article, I covered a brief introduction to Git and GitHub. Have a look here if you haven't yet:

My goal for this article is to cover how you can easily get started with Git & GitHub, how to install it, and some basic/IMP commands. So, let's start!

Setting up the environment

Code editor – I prefer VS Code

You can download from here if you don’t have

Git installation on your system

You can download from here if you don’t have

GitHub account

Create your GitHub account by following few simple steps

SSH keys for authentication

Using the SSH protocol, you can connect and authenticate to remote servers and services. With SSH keys, you can connect to GitHub without supplying your username and personal access token at each visit.

After installing Git on your system and Creating GitHub account, to connect to your GitHub account from your local machine via SSH you need to generating a new ssh key for the authentication. Follow the below documentation for detail overview on creating and adding SSH keys.

Generating a new SSH key and adding it to the SSH agent

When you set up SSH, you will need to generate a new SSH key and add it to the ssh-agent. It will generate two keys, one public and one private. You must add the public SSH key to your account on GitHub before you use the key to authenticate.
Follow the below documentation for the process of Adding public SSH key to your GitHub account

Basic Commands

Now that everything is set up, let's look at some common Git commands:

git Clone: Bring a repository that is hosted somewhere like github into a folder on your local machine
git add: Track your files and changes in git
git commit: Save your files in Git
git pull: Download changes from remote repo to your local machine, the opposite to push
git add . To track all unsaved files and changes for github
git commit -m "title" -m "description"
git push: Upload git commits to a remote repo, like github

Cloning GitHub Repo on your local machine

It's similar to downloading or cloning someone else's open source project and updating/modifying it or even working with your own online repository.

In Visual Studio code, open an empty folder and from the top of that folder open a terminal window
Clone with SSH that we just set up

Run the following command:

Git clone git@github.com:WardaLiaqat01/Test\-Repo.git (Repo will be cloned with all files and folders)
You can view all hidden files using ls command

Make some changes to the file and run git status command, it will show you all modified and untracked created files to be saved and commit.
git add . will save all new changes.
git commit -m “message you want to add with commit” -m “add description of commit” will save your changes locally.
git push origin master will add update your changes on your GitHub Repo

Due to the recent "Replacing master with main in GitHub" action, you may notice that there is a refs/heads/main. As a result, the following command may change from git push origin HEAD:master to git push origin HEAD:main

You can try git push origin HEAD:master as a more local-reference-independent solution. This explicitly states that you want to push the local ref HEAD to the remote ref master.

Git push documentation for detailed overview

After successful push you can see your all code changes are live on GitHub.

You can also see all the commits

Here are all the changes, green means it was added and red means it was removed. It's quite handy to be able to revert back to the previous version in case you don't like the changes.

Creating Repo locally and initializing on GitHub

Essentially, it is just as if you were creating your development project locally and then uploading it to Git

Create any Repo/Project locally in VS code
It won’t be a part of GitHub Repo as for now
After adding files your project and updating them we need to initialize our Repo so Git can recognize it
git init (To initialize local git Repo)
After your Repo is initialized then you can follow all the steps that we performed above (including status, add, commit etc.)
git push origin master: Here this command will through you an error

It’s because we didn’t clone this down from GitHub repository. We didn’t create this Repo on GitHub, we created it locally. So git is saying I don’t have any idea where to push this because it doesn’t connect to anything. So, we need to create that connection.
The easiest way is to do it from GitHub online interface

Create an empty GitHub repository with name and description and as a public repo

Now let's add that Repo as a origin so, git can recognize it.

git remote add origin [repo SSH/clone link] We are using this to add a reference to remote repo on GitHub
git remote -v will show all the remote repos
git push -u origin HEAD:main (-u for upstream, that means I can push simply by "git push" command in future)

Undoing in Git

Undoing can be quite helpful. In some cases, if you made some changes mistakenly and want to revert them, for example if you want to revert a commit, the git reset command can prove very helpful.

git reset : To undo add/stage changes.
git reset HEAD~1 : To undo commit (will undo the last/most recent commit)
git log : If we want yo undo any previous commit then this command will help
git reset (hash of that commit) : You will get this from logs but it won't remove data
git reset --hard (hash of that commit) : It will remove the code as well

Forking in GitHub

In a nutshell, forking means copying someone else's code into your own local repository to make updates and then create a pull request to the original repository after successful changes or create a pull request in your own local repository.

Conclusion

As a programmer, you'll find Git and GitHub quite useful. Thus, we learned how to get started using Git & GitHub with a few basic commands. I hope you have found this article helpful in some way.
If you have any comments, let me know.

if you would like to explore some more handy Git commands then visit the below URL.

Git Commands

Connect with me:

LinkedIn
Instagram
Twitter

What do you think about a developer without having a Github account?

Warda Liaqat — Mon, 18 Apr 2022 07:25:54 +0000

As per my thoughts, For being a solo developer, it is important to have feedback on your code so, you can make it better and open sourcing is a great practice to explore the world of different minds who are coding differently. Having a GitHub account and contributing to open source will let you do that.

Let me know what do you think about it?

Git & GitHub - Best Version Control and Source Code hosting platforms respectively!

Warda Liaqat — Fri, 15 Apr 2022 14:34:28 +0000

Introduction

Version controlling and Open-sourcing are quite hot terms nowadays. Git & GitHub are leading the market with rich offerings in these domains. Thought to share some thoughts/findings on it.

How did it all get started?

Thousands of lines of code are written every day by developers. Some of that code becomes part of the actual application, while other parts may be eliminated because of errors, ambiguities, and inconsistencies. Sometimes when developers add a new piece of functionality to the application they notice that it doesn't work as expected and we need to go back to the stage where this functionality wasn't present. As when they didn't use a version control system, it was not feasible or difficult to do so as they weren't keeping track of previous versions.

We Talked about "A Version Control System" but What is a version control System?

The purpose of version control systems is to keep track of and manage all the amendments made to the source code during the project's development. This ensures that all the changes are recorded. Also, if any mistakes are made in the current version of the code, we can roll back to the previous version.

Being a developer, especially a very productive and smart developer, you should keep track of all the changes that you make to your code, so that if you need to go back to a previous version. In this case, Git can come in handy and provide a lot of value.

Git and GitHub are the best version control and source code hosting platforms respectively among others

So, what is Git?

Git is a free, open-source software distributed version control system (DVCS) designed to manage all source code history.

Open source is a term that originally referred to open source software. Open source software is code that is designed to be publicly accessible—anyone can see, modify, and distribute the code as they see fit - By RedHat

You can go back to any of the previous versions of your source code
It can keep a history of commits, can reverse changes, and lets developers share code
Each developer must have Git installed on his or her local device to collaborate
It is commonly referred to as one of the best DevOps tools to understand and use in the developer space, and it’s among the most widely used tools today

What about GitHub?

GitHub, on the other hand, is a web-based platform for hosting Git repositories. In addition to Git's DVCS (Distributed version control system), SCM (Source code management), GitHub has some additional capabilities.

Your source code can be stored online, but you can also contribute to open-source projects, discuss another's work with other contributors, and have your work improved by others
You can also refer to GitHub as your dev project's online portfolio builder
Another reason why devs use GitHub is because of its powerful Actions which make it really simple to automate software workflows.
Additionally, users can easily set up a CI/CD, so once they commit changes, the CI/CD quickly pulls them from the GitHub repo and applies them to the developers’ own deployment

When Tom Preston-Werner, Chris Wanstrath and PJ Hyett founded GitHub in 2008, they entered a tough market, with established services such as SourceForge and offerings Google and Microsoft. Despite this, GitHub gained traction and, in July 2010, passed the 1m repository milestone.

GitHub broke through the 10m repository mark in December 2016 and is adding 20,000 repositories per day

Now GitHub is known as a best open-source contribution platform

By putting it simply, GitHub is an online platform for hosting source code repositories (Git repositories), while Git is a free open-source version control tool.
Git doesn’t require GitHub, but GitHub requires Git.

Do you have any thoughts on it???

References:

https://www.analyticsvidhya.com/blog/2021/09/git-and-github-tutorial-for-beginners/#:~:text=Image%204-,Difference%20between%20Git%20and%20GitHub,GitHub%20but%20GitHub%20requires%20Git.
https://kinsta.com/knowledgebase/git-vs-github/
https://www.newelectronics.co.uk/content/blogs/it-s-hard-for-software-developers-to-imagine-life-without-github

Big Data Processing, EMR with Spark and Hadoop | Python, PySpark

Warda Liaqat — Sun, 27 Mar 2022 19:03:00 +0000

Introduction:

AWS's cool data analysis services can be of significant help when it comes to processing and analyzing large amounts of data.

Use Case:

To demonstrate our data processing job, we will use EMR cluster and S3 (as a storage medium for data) along with Python code and the PySpark library. We will execute python code on a data set of Stack Overflow Annual Developer Survey 2021 and print out some results based on that data. Those results will then be stored in S3.

In case you are just starting with Big Data, I would like to introduce you to some terms we are going to work with, You may skip below few lines if you're already familiar.

EMR (Elastic MapReduce):

Amazon EMR is a managed cluster platform that simplifies running big data frameworks, such as Apache Hadoop and Apache Spark , on AWS to process and analyze vast amounts of data. Wanna dig more dipper?

Amazon S3:

Amazon S3 is object storage built to store and retrieve any amount of data from anywhere.
S3 is a global service. Simply say it works like Google drive.
Wanna dig more dipper?

Apache Spark:

Apache Spark is an open-source, distributed processing system used for big data workloads. Wanna dig more dipper?

Apache Hadoop:

Apache Hadoop is an open source framework that is used to efficiently store and process large datasets ranging in size from gigabytes to petabytes of data.Wanna dig more dipper?

Hadoop is designed to handle batch processing efficiently whereas Spark is designed to handle real-time data efficiently. Hadoop is a high latency computing framework, which does not have an interactive mode whereas Spark is a low latency computing and can process data interactively.

PySpark:

PySpark is the Python API for Apache Spark, an open source, distributed computing framework and set of libraries for real-time, large-scale data processing. Wanna dig more dipper?

Outline

Downloading a Data Set from Stack Overflow
Setup an Amazon S3 bucket with different folders
Setting up an EMR cluster
Write a python code to perform some analysis on data and print results
Connecting to Cluster via SSH and using PySpark to load data from Amazon S3
Viewing analysis results
Cleanup
Recap

Guided Procedure

1. Downloading a Data Set from Stack Overflow

Go to Stack Overflow Annual Developer Survey and download the latest data set for 2021
Ultimately, it will download four files, but in this case, we will only be using the "Survey Results Public" file

2. Setup an Amazon S3 bucket with different folders

Login to AWS Management Console
Navigate to S3 and buckets
Create a new bucket named as big-data-demo-bucket with Versioning enabled and encryption true
Click on your bucket once you've created it
Create two folders named as bigdata-emr-logs (for storing EMR logs) and data-source (for storing our source data file) with encryption enabled

Place your source data file in the source data folder

3. Setting up an EMR cluster

Search for EMR
Click on create cluster

An S3 bucket is needed to store EMR logs. When you don't want to do it manually, EMR will automatically create a bucket for you to store logs. Select a bucket and folder that we created in previous step
Select Spark with Hadoop and Zeppelin in the software configurations
In terms of hardware configurations, you can choose EC2 type based on your needs
For testing purposes, 3 instances would be sufficient. You may create as many as you need
Enable auto-termination, which will terminate your cluster if any error occurs during the creation process
You can also set the cluster to automatically terminate when it goes into idle state for long
It is also completely up to you whether or not to scale
Select a key pair under security and access to SSH after launching the cluster
If you do not have a keypair, you can create easily from EC2 dashboard

Once you click on the Create Cluster button, your cluster will be created. It usually takes 10 to 15 minutes for the cluster to become operational

4. Write a python code to perform some analysis on data and print results

Now let's write some code. A spark job will run this code to analyze the data and print out the results.


from pyspark.sql import SparkSession
from pyspark.sql.functions import col

S3_DATA_SOURCE_PATH = 's3://big-data-demo-bucket/data-source/survey_results_public.csv'
S3_DATA_OUTPUT = 's3://big-data-demo-bucket/data-output'


def main():
    spark = SparkSession.builder.appName('BigDataDemoApp').getOrCreate()
    all_data = spark.read.csv(S3_DATA_SOURCE_PATH, header=True)
    print('Total number of records in dataset: %s' % all_data.count())
    selected_data = all_data.where((col('Country') == 'United States of America') & (col('Age1stCode') == '11 - 17 years'))
    print('Total number of engineers who work more than 45 hours in the US is : %s' % selected_data.count())
    selected_data.write.mode('overwrite').parquet(S3_DATA_OUTPUT)
    print('Selected data was successfully saved to: %s' % S3_DATA_OUTPUT)

if __name__ == '__main__':
    main()

What does this code do?

Setting up a Spark session
Data reading from S3
Printing some results based on certain conditions
A S3 folder is created for storing the results

5. Connecting to Cluster via SSH and using PySpark to load data from Amazon S3

Don't forget to enable SSH connections before trying to SSH into your cluster. The port 22 needs to be added to the cluster's master security group

Follow the instructions accordingly to connect to your cluster if you are using Windows or Mac

I’m on windows so, I used putty for the connection

Use the vi main.py command to create a Python file using the Vim editor
Press I on your keyboard and paste your code
Press the ECS key to exit the insert mode
Type :wq to quite the editor with saving your changes
If you type cat main.py, you can view your code
To submit this spark job use spark-submit [filename]
Your job will begin executing

6. Viewing analysis results

Your three print results can be viewed in the logs after completion

You can now see that the latest logs are stored in the logs folder in S3. Additionally, you'll notice a new folder named data-output that contains all output results with success files has been created for you

7. Cleanup

You can then terminate the cluster to save money

When you terminate a cluster, all EC2 associated with it will also be terminated

8. Recap

This article showed how you can use EMR and Amazon S3 to process and analyze a vast amount of data collected from Stack Overflow developer survey to extract some useful insights

Welcome to the end of this article, Happy Clouding!

Let me know what do you think about it??

DEV Community: Warda Liaqat

Cloud 101 with AWS: From Concepts to a Real Serverless App

Why "Cloud 101" Needed a Rethink

The Big Questions We Started With

What We Built in the Workshop

The stack:

The Architecture (Big Picture)

Why This Approach Worked

Learning Beyond the Workshop

Final Thoughts

Building the Name Match Memory Game: My Experience with Amazon Q CLI

Introduction

Setting Up Amazon Q CLI

Using Q CLI to Build the Game

Game Features

1. Interactive Start Page

2. Game Mechanics

3. Data Management

4. Image Handling

Running the Game

Prerequisites

Setup Process

Starting the Game

Adding New People

My Learnings and Reflections

What's Next?

Conclusion

Revolutionize Your AWS App Development: AWS Application Composer and Our Helpdesk Project

Introduction

Visual Studio Code: Install AWS Application Composer Extension

Getting Started:

Pre-requisites:

Download Visual Studio Code - Mac, Linux, Windows

Install the AWS toolkit from Visual Studio Marketplace:

Install the AWS toolkit directly from VS code Extensions page:

How to get started with AWS Application composer in VS Code?

Options to sign in to AWS tool kit:

Access Application Composer from the Toolkit for VS Code

Overview of us utilizing AWS Application Composer in VS Code for our Helpdesk Project

Integration with AWS Services

Syncing Prototypes with Development Environment

Smooth Development Cycles

Real-World Scenarios

Conclusion:

References:

CI/CD Pipeline Hands-on | AWS Code Pipeline, Elastic Beanstalk, GitHub

Introduction

Contents:

Intro to AWS Code pipeline

Architecture of Our Code Pipeline

Let’s start building our Pipeline

Environment Setup

Set up Pipeline

Testing Our Code Pipeline

Update changes in code from GitHub:

Update changes in code locally & then commit to online repo:

Conclusion

Connect with me:

Getting intimate with CI/CD and CI/CD Pipeline

Introduction:

What is CI/CD?

Continuous Integration

How to Practice Continuous Integration

Continuous Deployment (CD)

Now let's move onto the concept of CI/CD Pipeline

CI/CD Pipeline Phases

CI/CD pipeline principles and best practices

Overall considerations to build a CI/CD pipeline

Connect with me:

References:

Why CI/CD? How was a life without CI/CD & how is it now?

Introduction:

An overview to CI/CD

Life Without Devops/CICD:

Life With Devops/CICD:

Why CI/CD?

DevOps service providers:

Connect with me:

Working with Git Branches!

Master Branch