resource "aws_instance" "manideep" {
  ami           = "ami-03d5c68bab01f3496"
  instance_type = "t2.micro"
  
  tags = {
    Name = "Manideep_Module"
  }
}

module "Manideep_Module" {
  source = "./modules/Manideep_module"
}

module "web-server" {
  source  = ".web-server/web-module"
  version = "0.0.10"
  
  cluster_name           = "webservers-stage"
  db_remote_state_bucket = "(BUCKET_NAME)"
  db_remote_state_key    = "stage/data-stores/mysql/terraform.tfstate"
  instance_type = "t2.micro"
  min_size      = 2
  max_size      = 2
}

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

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

  azs             = ["us-west-2a", "us-west-2b", "us-west-2c"]
  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"
  }
}

Step 1 – Create ec2-instance with key and group

Step 2 – COpy playbook using file prov*

Step 3 – Install Ansible using remote prov*

Step 4 – RUn Ansinle playbook command using remote prv*

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

  access_key = "XXXXXXXXXXXXX"
  secret_key = "XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX"
}
resource "aws_instance" "manideep" {
  ami           = "ami-03d5c68bab01f3496"
  instance_type = "t2.micro"
  key_name = "manideep"

    tags = {
    Name = "manideep"
  }
connection {
	
      type     = "ssh"
      user     = "ubuntu"
      private_key = file("manideep.pem")
      host = self.public_ip
}
 provisioner "file" {
    source      = "C:\Users\ansible\playbook.yaml"
    destination = "/tmp/"
  } 
provisioner "remote-exec" {
    inline = [
	  "sudo apt-get update",
          "sudo apt-get install ansible -y",
	  "sudo systemctl start ansible",
    ]
  }
provisioner "remote-exec" {
              inline = [
ansible-playbook -i inventory playbook.yaml -u root -k,
] 
}


}

– Types of Terraform variable – String

– Types of Terraform variable – List

– Types of Terraform variable – Map

-Types of Terraform variable – Boolean

#Types of Terraform variable - Number
terraform {
  required_providers {
    aws = {
      source  = "hashicorp/aws"
      version = "~> 3.0"
    }
  }
}

# Configure the AWS Provider
provider "aws" {
  region = "us-west-2"
  access_key = "XXXXXXXXXXXXXXXXX"
  secret_key = "XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX"
}


variable "usercount" {
  type = number
  description = "This is for demo of number variable"
  default = 3
}

resource "aws_instance" "manideep_number" {
  ami = "ami-03d5c68bab01f3496"
  instance_type = "t2.micro"
  count = "${var.usercount}"
  tags = {
    Name = "Manideep.${count.index}"
  }
  
}

#Types of Terraform variable – String 

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

# Configure the AWS Provider
provider "aws" {
  region = "us-west-2"
  access_key = "XXXXXXXXXXXXXXXXX"
  secret_key = "XXXXXXXXXXXXXXXXX"
}


variable "username" {
  type = string
  description = "This is for demo of string variable"
  default = "demouser"
}

resource "aws_instance" "manideep" {
  ami           = "ami-03d5c68bab01f3496"
  instance_type = "t2.micro"
  tags = {
    Name = "mani.${var.username}"
  }  
}

#Types of Terraform variable – List

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

# Configure the AWS Provider
provider "aws" {
  region = "us-west-2"
  access_key = "XXXXXXXXXXXXXXXXX"
  secret_key = "XXXXXXXXXXXXXXXXX"
}


variable "users" {
    type    = list
    default = ["dev1", "dev2", "dev3"]
    description = "This is for demo of list variable"
}

resource "aws_instance" "Manideep" {
  ami           = "ami-03d5c68bab01f3496"
  instance_type = "t2.micro"
  tags = {
    Name = "new.${var.users[0]}"
  } 
 
}

#Types of Terraform variable – Map

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

# Configure the AWS Provider
provider "aws" {
  region = "us-west-2"
  access_key = "XXXXXXXXXXXXXXXXX"
  secret_key = "XXXXXXXXXXXXXXXXXXXXXXXX"
}

variable "amis" {
  type = "map"
  default = {
    
    "us-west-2" = "ami-03d5c68bab01f3496"
  }
}


resource "aws_instance" "manideep" {
  ami           = "{$var.amis[var.region]}"
  instance_type = "t2.micro"
  
  tags = {
    Name = "Manideep_map"
  }
}

# Types of Terraform variable – Boolean

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

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

what is Ansible? Ansible is an open-source automation engine that helps in DevOps and comes to the rescue to improve your technological environment’s scalability, consistency, and reliability. It is mainly used for rigorous IT tasks such as configuration management, application deployment, intraservice orchestration, and provisioning

What is Docker? Enterprise Container Platform for High-Velocity Innovation. The Docker Platform is the industry-leading container platform for continuous, high-velocity innovation, enabling organizations to seamlessly build and share any application — from legacy to what comes next — and securely run them anywhere.

What is Terraform? Describe your complete infrastructure as code and build resources across providers. With Terraform, you describe your complete infrastructure as code, even as it spans multiple service providers. Your servers may come from AWS, your DNS may come from CloudFlare, and your database may come from Heroku. Terraform will build all these resources across all these providers in parallel.

Terraform script using group and key::

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

# Configure the AWS Provider
provider "aws" {
  region     = "us-west-2"
  access_key = "XXXXXXXXXXXXXXX"
  secret_key = "XXXXXXXXXXXXXXXXXXXXXXXXXX"
}

#aws resources
resource "aws_instance" "linux_instance" {
  ami           = "ami-0dc8f589abe99f538" # linux ami in aws
  instance_type = "t2.micro"
  
  tags = {
    Name = "linux_instance"
  }
}

• Jenkins is a free and open source automation server.
• It helps automate the parts of software development related to building, testing, and deploying
• it will support facilitating continuous integration and continuous delivery
• Jenkins can be installed through native system packages, Docker
• even run standalone by any machine with a Java Runtime Environment (JRE) installed
•  It supports version control tools, including AccuRev, CVS, Subversion, Git, Mercurial, Perforce, ClearCase and RTC
• It can execute Apache Ant, Apache Maven and sbt based projects as well as arbitrary shell scripts and Windows batch command
• Discover the 1800+ community contributed Jenkins plugins to support building, deploying and automating any project.
• Organizations can accelerate the software development process through automation.
• Plugins have been released for Jenkins that extend its use to projects written in languages other than Java. Plugins are available for integrating Jenkins with most version control systems and bug databases.
• Many build tools are supported via their respective plugins. Plugins can also change the way Jenkins looks or add new functionality.
• Jenkins is a self-contained Java program that is agnostic of the platform on which it is installed.
• Easy to install and configure plugins
• Jenkins will be installed on a server where the central build will take place.

Top 10 popular Jenkins Plugins::

• Kubernetes plugin
• Docker Plugin for Jenkins
• Jira Plugin
• Slack Notification Plugin
• Maven Plugin
• Amazon EC2 Plugin
• JUnit Plugin
• Pipeline Plugin
• Mailer Plugin
• Green Balls Plugin

Time series databases are simply measurements or events that are tracked, monitored, downsampled, and aggregated over time. 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

– How prometheus is good for time series metrix?

Prometheus is a very good tool for processing and monitoring time series data. This versatile tool can be used with Graphana, a statistics visualization, and anomaly observation tool. This tool can collect data from highly loaded servers, various IoT devices, complex data processing systems, and many more.

– What are components of prometheus?

•  Prometheus server: which scrapes and stores time series data
• client libraries: for instrumenting application code
• push gateway: for supporting short-lived jobs
• exporters: for services like HAProxy, StatsD, Graphite, etc.
• alertmanager: to handle alerts

– How prometheus works?

Prometheus can scrape numerical data and store it as a time series in a local time series database. It can also integrate with remote storage options.In addition to the stored time series, impermanent times series from the source are produced by queries. These series are recognized by metric name and key value pairs known by labels. 

- name: group creation 
  hosts: hostserver
  tasks:
   - name: deploy
     group:
       name: deploy
       state: present
 

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

- name: user creation
  hosts: hostserver
  tasks:
    - name: deploy-user
      user: 
        name=deploy-user 
        groups=deploy
        shell=/bin/bash
        

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

- name: installinng apache on centos
  hosts: web

  tasks:
  - name: Apache installation
    ansible.builtin.yum:
      name: httpd
      state: latest
  

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

- name: Update web servers
  hosts: web

  tasks:

  - name: Starting a Apache Server
    ansible.builtin.service:
      name: httpd
      state: started

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

#create a file called index.html using touch or vi 
- name: file creation
  hosts: web
task:
- name: creating index.html
    file:
       dest: /var/www/html/index.html
       status:touch

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

- name: rebooting self machine
  hosts: web
    task:
    - name: Rebooting machine 
        reboot:
 

1. 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

1. 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

How to verify?
$ more /etc/group | grep deploy

ansible localhost -m ansible.builtin.group -a”name=deploy state=present”

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.

How to verify?
$ more /etc/passwd | grep deploy-user

ansible -m user -a “name=deploy-user group=deploy shell=/bin/bash”

Program 3 – Write a Ansible Adhoc commands install package named “httpd” in RHEL/centos.

How to verify?
$ which httpd

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

Program 4 – Write a Ansible Adhoc commands to start and enable the service named “httpd”

How to verify?
$ ps -eaf | grep httpd

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

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

How to verify?
Browse http://x.x.x.x:80

ansible localhost -m copy -a”src=index.html dest=/var/www/html/index.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.

How to verify?
Browse http://x.x.x.x/second.html

ansible all -i ACS,ARS, -m copy -a”src=index.html dest=/var/www/html/second.html” -u root -k

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

How to verify?
$ which git
$ which wget

ansible all -m ansible.builtin.package -a “name=git,wget”

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

How to verify?
$ ls

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 reboot -a “name=reboot”

Program 10 – Write a Ansible commands to touch a file called “devopsschool.txt” in /opt/ and delete after using ansible adhoc command.

-ansible all -m ansible.builtin.file -a “path = /opt/devopsschool.txt state = touch “

-ansible all -m ansible.builtin.file -a “path = /opt/devopsschool.txt state = absent”

A Kubernetes service is a logical abstraction for a deployed group of pods in a cluster On the other hand, a service is responsible for exposing an interface to those pods, which enables network access from either within the cluster or between external processes and the service.

types of services offered::

• ClusterIP. Exposes a service which is only accessible from within the cluster.
• NodePort. Exposes a service via a static port on each node’s IP.
• LoadBalancer. Exposes the service via the cloud provider’s load balancer.
• ExternalName. Maps a service to a predefined externalName field by returning a value for the CNAME record.

Use Of Service named Kubernetes in default Namespace::

A Service in Kubernetes is an abstraction which defines a logical set of Pods and a policy by which to access them. Services enable a loose coupling between dependent Pods. A Service is defined using YAML (preferred) or JSON, like all Kubernetes objects.

How services works::

For a service to work, the label selector at the load balancer should match the label selector of the pod so that the endpoint IP can be configured and the services can be accessible accordingly.

compile lang:: A compiled language is a programming language whose implementations are typically compilers like c, c++,ALGOL,BASIC

interpreter lang::  interpreter is a computer programming  that directly executes instructions written in a programming and scripting

Declarative lang:: In computer science, declarative programming is a programming paradigm—a style of building the structure and elements of computer programs.

Example of Declarative Lang:: we have some language like sql,prolog

Pros and Cons::

pros : short,efficient code

cons : Sometimes hard to understand for external people

Types of PODS::pod has two types which run on single container and multiple container

What POD contains:: pod contains container each container has it own port number but they all are in same network it has volume, containerized app

pod life cycle:: pod has mainly three phase

pending phase : when it is initiated,

Running phase: when it is in use

Succeed/fail: when the pod is exited/terminated

IMAGE ::

Why Kubernetes:: In real time need not to go down if we need 100 container to run the specific task we need to maintain it manually with out going it to down , at that time we use kubernetes to do that task, kubernetes will maintain the desired requirement it will automate if container goes down kubernetes will create a new container automatically

image::

Kubernetes Architecuture::In kubernetes we have two notes master and worker in master node we have apiserver,scheduler ,cluster store, controller for high availability we can create upto 3 master , in worker node we have docker, kubelet, kube-proxy

How Kubernetes Works:: when a request comes apiserver will handle and the content will be stored in cluster-store,controller will controll all the managing task scheduler will schedule the task which container will do which task in worker node we can have any number of pod and each pod can contain any number of container but all the master and worker should be in one cluster