DEV Community: sumanbgl

Microsoft Azure Administrator AZ-104 Bootcamp - Day 03

sumanbgl — Fri, 15 Jul 2022 15:42:55 +0000

I attended the Microsoft Azure Administrator AZ-104 Bootcamp by Azure Developer Community sponsored by Whizlabs and Microsoft.

In Day 03 of the Microsoft Azure Administrator AZ-104 Bootcamp, I learnt about the Azure Storage Services and its usage.

From these learnings, I developed a python content management application that uses blob-storage to store photos and Azure SQL server to store the structured data.

Below are the steps followed.

Link to register for the Bootcamp -
https://azdev.reskilll.com/event/Az104~doon

Links to all the sessions in this Bootcamp series.
Day1: https://www.youtube.com/watch?v=En_0-P7dkEA
Day2: https://www.youtube.com/watch?v=z8zCX0U-yGE
Day3:https://www.youtube.com/watch?v=3_yRuplWfhk

Cloud-Native Application Ecosystem

sumanbgl — Fri, 16 Jul 2021 11:15:34 +0000

This article defines what a cloud-native application is and summaries the various tools involved in designing, developing, deploying and operating a cloud-native application.

Definition

Cloud-Native applications are scalable applications that are built for and execute on modern, dynamic environments like public, private, hybrid cloud.
Below diagram shows the varied definitions of cloud-native application from different vendors.

Cloud-Native Explained

Cloud-Native applications are built using microservices, containers, orchestration and automation. They are designed for the cloud to take advantage of its elastic infrastructure for scaling up and down on-demand. They increase the speed, flexibility and innovation in the development cycle enabling faster delivery and new user experience.
Containers, service meshes, microservices, immutable infrastructure, CI/CD tooling, observability tools are the prominent technologies that enable adoption of cloud-native application development.

Cloud-native applications being loosely coupled systems offers the benefits of resiliency, manageability and observability. Together with robust automation, allows engineers to make high-impact high-quality changes frequently and predictably with minimal toil.

Cloud-Native Application Ecosystem

This section mentions the commonly encountered terms, tools and processes used in the life-cycle of a cloud-native application.

Microservices

Microservices: Small, independent, loosely coupled services. They promote agility in development lifecycle. Several instances of stateless microservices facilitate resilience and elastic scalability and low-risk system evolution.

Below image shows different microservices working together in a typical e-commerce application.

Below are some of the ways to implement microservices.

Frameworks and Programming languages: Development teams are free to select tools that best the application functionality.
APIs: Well-defined interfaces based on REST, GraphQL or gRPC technologies provided by third party services and microservices promote faster development and collaboration between teams.

Tools

This section introduces to the commonly used tools in the cloud-native ecosystem.

Containers: Microservices are frequently packaged and deployed as Docker images for portability and optimized resource consumption. Docker is popularly used container tool. Container makes sure that the application always run in all the environments.

Orchestration: Containers are managed by orchestration tools like Kubernetes, Mesos, Docker Swarm for automated deployment, operation, scaling and resilience of application at scale. Orchestrators offer below functions:

Configuration
Provisioning
Availability
Scaling
Resource allocation
Load balancing
Health monitoring

Kubernetes is the king among orchestrators. It provides the uses the below resources to achieve it's functionality.
Pod
Deployment
Replica Set
Service
Ingress
ConfigMap
Namespace

Continuous Integration/Continuous Delivery Tooling: Application code and required infrastructure expressed as "infrastructure as code" are checked into source control systems like Git, allowing rapid iteration through automated dev, test, and prod pipelines.

Monitoring: Distributed applications expose new faults and operations teams turn to central monitoring systems like Prometheus to provide a single view of the entire system.

Security: OAuth, OIDC, JWTs, identity providers, API gateways, and automatic container patching provide new mechanisms to cover attack surface areas.
Service Mesh: The goal of the mesh is to guarantee secure communications between each independent container application/microservice and be able to redirect traffic in the
event of failures.

Conclusion

This article introduced what a cloud-native application is, terms and tools in cloud-native application ecosystem.

References:

Images are taken from slides on Complete Idiot's guide to Cloud-Native Application talk during KubeSummit 2021.

Anatomy of a Cloud-Native Application.

sumanbgl — Thu, 15 Jul 2021 10:25:16 +0000

Definition

Cloud-Native applications are scalable applications that are built for and execute on modern, dynamic environments like public, private, hybrid cloud.

Cloud-Native Explained

Anatomy of a Cloud-Native Application

Following are some key elements that are commonly found in cloud-native applications:

Microservices: Small, independent, loosely coupled services. They promote agility in development lifecycle. Several instances of stateless microservices facilitate resilience and elastic scalability and low-risk system evolution.

Frameworks and Programming languages: Development teams are free to select tools that best the application functionality.
APIs: Well-defined interfaces based on REST, GraphQL or gRPC technologies provided by third party services and microservices promote faster development and collaboration between teams.
Containers: Microservices are frequently packaged and deployed as Docker images for portability and optimized resource consumption.
Orchestration: Containers are managed by orchestration tools like Kubernetes, Mesos, Docker Swarm for automated deployment, operation, scaling and resilience of application at scale. Orchestrators offer below functions:
- Configuration
- Provisioning
- Availability
- Scaling
- Resource allocation
- Load balancing
- Health monitoring

Continuous Integration/Continuous Delivery Tooling: Application code and required infrastructure expressed as "infrastructure as code" are checked into source control systems like Git, allowing rapid iteration through automated dev, test, and prod pipelines.
Monitoring: Distributed applications expose new faults and operations teams turn to central monitoring systems like Prometheus to provide a single view of the entire system.
Security: OAuth, OIDC, JWTs, identity providers, API gateways, and automatic container patching provide new mechanisms to cover attack surface areas.
Service Mesh: The goal of the mesh is to guarantee secure communications between each independent container application/microservice and be able to redirect traffic in the
event of failures.

Conclusion

This article has introduced the different aspect of a cloud-native application.

Income,Expense Tracker using Azure SQL Database and App Service

sumanbgl — Wed, 07 Apr 2021 18:14:15 +0000

This blog will cover steps to develop a single page Flask based web-app using Azure Services.

Solution Overview

A single page Flask based income and expense tracker web application for a single user is developed and deployed on Azure Platform. It integrates with MS Single Sign-on using msal library

Azure Services Used

Azure SQL Database
Azure App Service
Azure Active Directory

Application Overview

In this simple income-expense tracker web application, a user can log in, view income, expenses and add income, expenses. Income and/or expense is referred to as an item. Each item consists of a date of expense, category, amount. The item(s) are stored in Azure SQL Server.

The income-expense tracker includes the following components:

A webapp using Python with the Flask framework.
A SQL database that contains a users and income-expense table for the webapp to query.

Prerequisites

Python 3.7 or higher version
Visual Studio Code Editor

Development Environment Setup on Linux

Install Visual Studio Code
Install Python 3
Create Python Virtual Environment - Execute the below command to create python virtual environment

# Create the environment
python3 -m venv venv
# Activate the environment
source ./venv/bin/activate

Download requirements.txt. It contains all the required libraries. Execute the below command to install all of them.

pip install -r requirements.txt

Overview of Application Code

Tables

CREATE TABLE USERS (
    id INT NOT NULL IDENTITY(1, 1),
    username VARCHAR(64) NOT NULL,
    password_hash VARCHAR(128) NOT NULL,
    PRIMARY KEY (id)
);

CREATE TABLE INCOME_EXPENSE(
    id INT NOT NULL IDENTITY(1, 1),
    category VARCHAR(150) NOT NULL,
    date DATE NOT NULL DEFAULT(GETDATE()),
    amount INT NOT NULL,
    user_id INT NOT NULL,
    PRIMARY KEY (id),
    FOREIGN KEY (user_id) REFERENCES users(id)
);

Sample Data

INSERT INTO dbo.users (username, password_hash)
VALUES ('admin', 'pbkdf2:sha256:150000$QlIrz6Hg$5f4cd25d78a6c79906a53f74ef5d3bb2609af2b39d9e5dd6f3beabd8c854dd60')

INSERT INTO dbo.income_expense (category, amount, user_id)
VALUES (
    'income',
    5000,
    1
);

Models

class User(UserMixin, db.Model):
    __tablename__ = 'users'
    id = db.Column(db.Integer, primary_key=True)
    username = db.Column(db.String(64), index=True, unique=True)
    password_hash = db.Column(db.String(128))

    def __repr__(self):
        return '<User {}>'.format(self.username)

class Income_Expense(db.Model):
    __tablename__ = 'income_expense'
    id = db.Column(db.Integer, primary_key=True)
    category = db.Column(db.String(150))
    date = db.Column(db.Date)
    amount = db.Column(db.Integer)
    user_id = db.Column(db.Integer, db.ForeignKey('users.id'))

    def __repr__(self):
        return '<Amount {}>'.format(self.amount)

    def save_changes(self, form, userId, new=False):
        self.category = form.category.data
        self.amount = form.amount.data
        self.date = form.date.data
        self.user_id = userId

        if new:
            db.session.add(self)
        db.session.commit()

Forms

class LoginForm(FlaskForm):
    username = StringField('Username', validators=[DataRequired()])
    password = PasswordField('Password', validators=[DataRequired()])
    remember_me = BooleanField('Remember Me')
    submit = SubmitField('Sign In')

class IncomeExpenseForm(FlaskForm):
    category = StringField('Category', validators=[DataRequired()])
    amount = IntegerField('Amount', validators=[DataRequired()])
    date = DateField('Date', format='%m/%d/%y',
                          render_kw={'placeholder': '3/16/21 for March 16, 2021'}, validators=[DataRequired()])
    submit = SubmitField('Save')

config.py - contains the code to read the configurable values from an external source like environment variables.

views.py - contains the routing logic for login, logout, creating and showing items.

DEV Community: sumanbgl

Microsoft Azure Administrator AZ-104 Bootcamp - Day 03

Cloud-Native Application Ecosystem

Definition

Cloud-Native Explained

Cloud-Native Application Ecosystem

Microservices

Tools

Conclusion

References:

Anatomy of a Cloud-Native Application.

Definition

Cloud-Native Explained

Anatomy of a Cloud-Native Application

Conclusion

Income,Expense Tracker using Azure SQL Database and App Service

Solution Overview

Azure Services Used

Application Overview

Prerequisites

Development Environment Setup on Linux

Overview of Application Code

Azure Infrastructure Setup

Resource Group and Azure SQL Database Creation

Integration with Active Directory

Azure App Service Creation and Deployment