terraform {
  required_providers {
    aws = {
      source  = "hashicorp/aws"
      version = "~> 3.0"
    }
   github = {
      source  = "integrations/github"
      version = "~> 4.0"
    }
  }
}

provider "aws" {
  region = "us-west-2"
  access_key = " "
  secret_key = " "
}

module "harish"{

  source = "./harish"

}

module "vpc" {
  source = "terraform-aws-modules/vpc/aws"

  name = "my-vpc"
  cidr = "10.0.0.0/16"

  azs             = ["eu-west-1a", "eu-west-1b", "eu-west-1c"]
  private_subnets = ["10.0.1.0/24", "10.0.2.0/24", "10.0.3.0/24"]
  public_subnets  = ["10.0.101.0/24", "10.0.102.0/24", "10.0.103.0/24"]

  enable_nat_gateway = true
  enable_vpn_gateway = true

  tags = {
    Terraform = "true"
    Environment = "dev"
  }
}

variable "num_of_groups" {
  type = number
  description = "Number variable"
  default = 3
}

resource "aws_iam_group" "developers" {

  count = "${var.num_of_groups}"
  name = "developers.${count.index}"

}

String

variable "instance_name" {
  description = "Value of the Name tag for the EC2 instance"
  type        = string
  default     = "ExampleAppServerInstance"
}
 resource "aws_instance" "app_server" {
   ami           = "ami-08d70e59c07c61a3a"
   instance_type = "t2.micro"

   tags = {
-    Name = "ExampleAppServerInstance"
   Name = var.instance_name
   }
 }

List

variable "gitrepos" {
    type    = list
    default = ["harish_1", "harish_2", "harish_3"]
    description = "list variable"
}


resource "github_repository" "repo1" {
  name = "${var.gitrepos[0]}"
  description = "creating first repository"
  private = false
}

resource "github_repository" "repo2" {
  name = "${var.gitrepos[1]}"
  description = "creating secondrepository"
  private = false
}

resource "github_repository" "repo3" {
  name = "${var.gitrepos[2]}"
  description = "creating third repository"
  private = false
}

Map

variable "user_name" {
   type = map
  default = {
      "user1" = "hari_1"
      "user2" = "hari_2"
      "user3" = "hari_3"
}
}
resource "aws_iam_user" "iamuser" {
  for_each = var.user_name
  name = "${each.value}-iam"
}

Boolean

variable "set_password" {
  type    = bool
  default = false
}

resource "git_password" "example" {
  create_password = "${var.set_password}"
}

Terraform Script to create linux Ec2 instance with security groups

terraform {
  required_providers {
    aws = {
      source  = "hashicorp/aws"
      version = "~> 3.0"
    }
  }
}
provider "aws" {
  region = "us-west-2"

  access_key = "my-access-key"
  secret_key = "my-secret-key"
}
resource "aws_instance" "hari-first-ec2" {
  ami           = "ami-03d5c68bab01f3496"
  instance_type = "t2.micro"

    tags = {
    Name = "Harish"
  }
}
resource "aws_security_group" "ResourceGroup" {
  name        = "allow_tls"
  description = "Allow TLS inbound traffic"
  vpc_id      = aws_vpc.main.id

  tags = {
    Name = "harishResourceGroup"
  }
}
resource "aws_key_pair" "deployer" {
  key_name   = "deployer-key"
  public_key = ""
}

• Jenkins is an open-source automation tool
• it is an continues integration tool.
• It lets you execute a series of actions to achieve the continuous integration process.
• Jenkins can integrate every Devops tools such as Jira, git,Sonarqube etc.
• it can perform automatically the build and test and gives immediate feedback
•  making it easier for users to obtain a fresh build.
• it can also schedule and gives feedback.
• Jenkins releases are, Jenkins, enterprise Jenkins, Jenkinsx, and blueocean.
• Jenkins is the community version and free.
• it is developed in java.
• platform independent.
• powered by very strong community.
• in Jenkins everything is optional
• it is extremely easy to install and use
• powered by 1000+ plugins(100+ features)

Most Popular Plugins in Jenkins

• Kubernetes.
• Swarm.
• Amazon Elastic Container Service.
• Azure Container Service.
• Dashboard View.
• View Job Filters.
• Folders.
• Jira.
• Performance
• Performance Publisher
• Build Pipeline
• Mailer
• Monitor

A time series database is a database optimized for time stamped or time series data. This could be server metrics, application performance monitoring, network data, sensor data, events, clicks, trades in a market, and many other types of analytics data. A time series database is built specifically for handling metrics and events or measurements that are time-stamped.

How Prometheus is good for time series metrics ?

Prometheus fundamentally stores all data as time series: streams of timestamped values belonging to the same metric and the same set of labeled dimensions. Besides stored time series, Prometheus may generate temporary derived time series as the result of queries.

What are components of Prometheus ?

The Prometheus consist of multiple components:

• Prometheus Server – which scrapes and stores time series data
• Client Libraries – used for instrumenting application code
• Push gateway – used for supporting short-lived jobs
• Exporters – used for services like HAProxy, StatsD, Graphite, etc.
• Alert Manager – which handle alerts

How Prometheus works?

Prometheus scrapes metrics from instrumented jobs, either directly or via an intermediary push gateway for short-lived jobs. It stores all scraped samples locally and runs rules over this data to either aggregate and record new time series from existing data or generate alerts.

- name: Create a group
  hosts: group
  tasks:
   - name: Add group "deploy"
     group:
       name: deploy
       state: present

2.Write a Ansible Playbook to create a user called “deploy-user” which is part of group called “deploy” and with /bin/bash shell.

- name: Create a user
  hosts: user
  tasks:
    - name: Add user "deploy-user"
      user: 
        name=deploy-user groups=deploy password="" shell=/bin/bash 
        append=yes 
        state=present

3. Write a Ansible Playbook to install package named “httpd” in RHEL/centos.

- name: To install  an httpd webserver
  hosts: web
  tasks:
  - name: Install httpd packages 
    yum:
      name: httpd
      state: present

4. Write a Ansible Playbook to start and enable the service named “httpd”

- name: To start and enable an httpd webserver
  hosts: web
  tasks
    - name: start httpd
    service:
      name: httpd 
      state: started


  - name: enable httpd
    service:
      name: httpd 
      enabled: yes

5. Write a Ansible Playbook to create a file called “index.html” in /var/www/html with some dummy html contents.

- name: creating a file
  hosts: all
    tasks:
    - name: create a file index.html
      file:
        path: "/var/www/htmlindex.html"
        state: touch

    - name: adding contents to indexfile
    blockinfile:
      dest: /var/www/html/index.html
      block: |
        <html>
        <h1> Welcome to HP Ansible class </h1>
        </html>

6. Write a Ansible Playbook to reboot a self machine.

- name: rebooting self machine
  hosts: web
    task:
    - name: Reboot a Linux machine 
        reboot:
        reboot_timeout: 1800

7. Write a Ansible Playbook to install a package called “git”, “wget”.

- name: To install a package "git" and "wget"
  hosts: web
  tasks:
  - name: Install git packages 
    yum:
      name: git
      state: present
 
  - name: Install wget packages 
    yum:
      name: wget
      state: present

8. Write a Ansible Playbook to clone git repo. thttps://github.com/scmgalaxy/ansible-role-template

- name: Cloning git repo
  hosts: web
  environment:
      http_proxy: 'http://web-proxy:8080'
      https_proxy: 'http://web-proxy:8080'
  tasks:
  - name: cloning....
    git: 
      repo=https://github.com/scmgalaxy/ansible-role-template
      clone=yes 
      dest=./ansible-role-template

$ ansible -m groupadd -a”name=deploy “

Program 2 – Write a Ansible Adhoc Commands to create a user called “deploy-user” which is part of group called “deploy” and with /bin/bash shell.

$ ansible -m usseradd -a”name=deploy-user group=deploy”

3. Ansible Adhoc commands install package named “httpd” in RHEL/centos.

$ ansible localhost -m yum -a “name=httpd state=present”

 4. Ansible Adhoc commands to start and enable the service named “httpd”

$ ansible localhost -m service -a”name=httpd state=started enabled=yes”

Program 5 – Write a Ansible commands to create a file called “index.html” in /var/www/html with some dummy html contents.

$ ansible localhost -m copy -a”src=index.html dest=/var/www/html”

Program 6 – Write a Ansible commands to copy a file called “second.html” in /var/www/html/second.html with some dummy html contents.

$ ansible localhost -m copy -a”src=second.html destination=/var/www/html/second.html

Program 7 – Write a Ansible commands to install a package called “git”, “wget”.

$ ansible all -m ansible.builtin.git -a”name=git”

$ ansible all -m ansible.builtin.git -a”name=wget”

Program 8 – Write a Ansible Adhoc commands to clone git repo. https://github.com/scmgalaxy/ansible-role-template.

$ ansible all -m ansible.builtin.git -a”repo=https://github.com/scmgalaxy/ansible-role-template clone=yes”

Program 9 – Write a Ansible commands to reboot a self machine.

$ ansible all -m ansible.builtin.reboot -a”name=reboot the machine”

 A service is responsible for enabling network access to a set of pods. The set of Pods targeted by a Service is usually determined by a selector.

What are the types of Services?

1.Cluster Ip : A service which is only accessible within the cluster.

2.NodePort : A service which is accessible outside the cluster via node ip.

3.NodePort :  A service which is accessible via the cloud provider’s load balancer.

4.ExternalName : External names are ones that are visible to other compilation units.

How service works?

The most basic type of load balancing in Kubernetes is actually load distribution, which is easy to implement at the dispatch level. Kubernetes uses two methods of load distribution, both of them operating through a feature called kube-proxy, which manages the virtual IPs used by services.

What is the use of service named with “kubernetes” in default namespace?

The kubernetes service in the default namespace is a service which forwards requests to the Kubernete API server. All the requests to the kubernetes default service from the cluster will be routed to the configured Endpoint IP

apiVersion:v1
kind: Pod
metadata:
  name: nodehelloworld.example.com

  labels:
    app: helloworld
spec:
  containers:
  - name:devopsschool1 
    image:scmgalaxy/nginx-devopsschoolv1

    ports:
    - name: nginx-port
      containerPort: 80

  - name:devopsschool2
    image: webimp/mysql-56-slim

    ports:
    - name: mysql-port
      containerPort: 3306

• It executes entire program in a single shot
• It is faster and more effecient
• eg : c, c++ …

Interpreted Language:

• It executes one line at a time
• It is slow compare to complied language
• eg: python, …

Declarative Language:

• it is non-procedular language
• declarative languages are fact oriented
• eg : json, xml, sql

Pod is atomic unit of scheduling in the Kubernetes, It contains one or more containers.

Types Of Pods :

There are two methods in pods :

1. loose coupling – Pod with one container

2. tight coupling – pod with multiple containers

What pod contains ?

Inside a Pod we can have one or more containers .

Life cycle of Pod :

There are three stages in life cycle of pod:

1.pending – when the pod is added newly

2.running – when the container execute without issues

3.succeeded/failed – when the container finishes its execution

Kubernetes is a open source container orchestration platform and supports datacenters outsourcing to public cloud service providers

Why Kubernetes?

Kubernetes provides services, support and tools are widely used.

Kubernetes Architecture

Kubernetes Architecture contains Master Node composed of etcd cluster, api-server, controller manager, scheduler and nodes composed of kublet and kube-proxy

How Kubernetes Works ?

Kubernetes keeps track of container application that are deployed into the cloud and it restarts, shutdown the containers .