resource "aws_instance" "judith-ec2" {
  ami           = "ami-03d5c68bab01f3496" # us-west-2
  instance_type = "t2.micro"
  key_name 		= "judith7"
  tags = {
    Name = "judith inst"
  }
  
  connection {
      type     = "ssh"
      user     = "ubuntu"
      private_key = file("judith7.pem")
      #host = aws_instance.web.public_ip
      host = self.public_ip
  }

  provisioner "local-exec" {
    command = "touch devopsschool-local"
  }
  
  provisioner "remote-exec" {
    inline = [
      "sudo apt-get update",
      "sudo apt-get install wget -y",

      
      ]
  }
  
  provisioner "file" {
    source      = "terraform.tfstate.backup"
    destination = "/tmp/"
  } 
}

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

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


# Configure the GitHub Provider
provider "github" {
 token = "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" 
}

Variable number:

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

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

Variable string:

variable "reponame" {
  type = string
  description = "This is for demo of string variable-judith"
  default = "day3-broad"
}

resource "github_repository" "string variable" {
  name        = "${var.reponame}"
  description = "My awesome codebase"
  private = false
}

Variable list:

variable "users" {
    type    = list
    default = ["devopsschool1", "devopsschool2", "devopsschool3"]
    description = "This is for demo of list variable"
}

variable "gitrepos" {
    type    = list
    default = ["devopsschool1", "devopsschool2", "devopsschool3"]
    description = "This is for demo of list variable"
}

resource "aws_iam_user" "judith" {
  name = "${var.users[0]}"
}

resource "github_repository" "repo1" {
  name = "${var.gitrepos[0]}"
  description = "My awesome codebase"
  private = false
}

resource "github_repository" "repo2" {
  name = "${var.gitrepos[1]}"
  description = "My awesome codebase"
  private = false
}

resource "github_repository" "repo3" {
  name = "${var.gitrepos[2]}"
  description = "My awesome codebase"
  private = false
}

map file

variable "account_name" {
   type = map
  default = {
      "account1" = "devops1"
      "account2" = "devops2"
      "account3" = "devops3"
}
}
resource "aws_iam_user" "iamuser" {
  for_each = var.account_name
  name = "${each.value}-iam"
}
resource "aws_instance" "judith-ec2" {
  ami           = "0fb0225bafc2f76c5" # us-west-2
  instance_type = "t2.micro"
 
  tags = {
    Name = "judith"
  } 
}

boolean file:

Docker is platform as a service whereas terraform and ansible are infrastructure as a service

Ansible is suitable for small, temporary, and fast deployments.

Terraform is better when it comes to managing cloud services below the server.

 Terraform is an open source, IaC platform. Whereas, Ansible is an open source configuration management tool. Developers can use Ansible and Terraform at the same time

Terraform uses HCL,Ansible uses Yaml,Docker uses namespaces ,images

Terraform uses to create resources and services .ansible to configure resourses

Write a terraform script where you create a linux ec2 instance with Security group and key defined so you should be able to use key to login to ec2 instance.

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

# Configure the AWS Provider
provider "aws"  {
  region     = "us-west-2"
  access_key = "()"
  secret_key = "()"
}
resource "aws_key_pair" "deployer" {
  key_name   = "deployer-key"
  public_key = "ssh-rsa 
}
resource "aws_security_group" "instance" {
  name = "terraform-example-instance"
  ingress {
    from_port   = 8080
    to_port     = 8080
    protocol    = "tcp"
    cidr_blocks = ["0.0.0.0/0"]
  }
}
variable "security_group_id" {}

data "aws_security_group" "selected" {
  id = var.security_group_id
}

10 popular jenkins plugins:

1. Kubernetes

The “Kubernetes” plugin is great for automating build agents on a Kubernetes cluster. Essentially, the plugin will dynamically create Kubernetes Pods that house a build agent that has started and will stop the agent once the build has completed.

2. Swarm

This interesting plugin is useful if you plan on using Docker Swarm. It helps make life easier by allowing you to add worker nodes to a Jenkins master node effectively creating a cluster and making scalability much easier.

3. Amazon Elastic Container Service

A plugin that deploys build agents to an existing Amazon ECS cluster. These builds run within separate Docker containers that are removed upon completion of the build.

4. Azure Container Service

Similar to Amazon ECS, this plugin requires an existing cluster on Azure. Keep in mind that Azure Container Services is being deprecated by Microsoft, but this plugin still supports it as well as Azure Kubernetes Service.

5. Dashboard View

Dashboard View enables you to create a customized view within the Jenkins dashboard. The user is able to select which jobs they want to include in the view as well as the different portlets.

6. View Job Filters

The “View Job Filters” plugin lets you choose from a wide range of filters to help manage lots of jobs. Basically, this lets you see only the jobs you want to see within a view.

7. Folders

Tired of looking at a giant list of jobs? The “Folders” plugin allows you to organize them into your own customized folder structure. 

8. Jira

“Jira” is an open source plugin that does exactly what it says. Once installed, you can integrate your Jenkins instance with Atlassian Jira Software.

9. Performance

With this free plugin, you can run performance reports for your favorite test suites. Supported suites include JUnit, JMeter, Taurus, and others. 

10. Performance Publisher

The “Performance Publisher” plugin generates global and trend reports that can be used for test result analysis. The really cool part is that it works with any test suite. 

Prometheus is an open-source systems monitoring and alerting toolkit.

Time Series database:

designed to store and retrieve data records that are part of a “time series,”

Time series is a set of data points that are associated with timestamps which provide a critical context for each of the data points in how they are related to others.

Prometheus is good for time series metrix:

sophisticated local storage subsystem. For indexes, it uses Level DB

for bulk data it has own custom storage layers, which organizes sample data in chunks of constant size.

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.
• Alert manager: to handle alerts
• various support tools

Most Prometheus components are written in Go, making them easy to build and deploy as static binaries.

Prometheus working:

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.

It scrapes metrics by any of the following ways:

• By instrumenting
• By using the prebuilt exporters
• By using the Pathgateway

Build many sub-playbooks and aggregate them via include statements.
- include: playbook-1.yml
- include: playbook-2.yml

Note - 
include is deprecated. docs.ansible.com/ansible/latest/playbooks_reuse.html import_playbook: foo is the right way to go

For newer versions of Ansilbe, you can build many sub-playbooks and aggregate them via import_playbook statements:
---
- import_playbook: A-systemd-networkd.yml
- import_playbook: B-fail2ban-ssh.yml
- import_playbook: C-enable-watchdog.yml

<strong>playbook1.yaml:group </strong>                                ---create group
- name: Deploying group
  hosts: web

  tasks:
  - name: create group
    group:
      name: deploy
      state: present
  
<strong>playbook-2:httpd</strong>                                  -----install http package
- name: Start the first play
  hosts: web
  
  tasks:
  - name: Install the latest version of Apache
    yum:
      name: httpd
      state: latest
  - name: Copy file with owner and permissions
    copy:
      src: index.html
      dest: /var/www/html/index.html
  - name: Start service httpd, if not started
    service:
      name: httpd
      state: started


<strong>playbook-3:mysql </strong>                                  ------install mysql package
- name: Start the first play
      
  hosts: db
  
tasks:
  - name: Install the latest version of Apache
    yum:
      name: mysql
      state: latest
  - name: Start service httpd, if not started
    service:
      name: mysqld
      state: started

<strong>playbook4:installgit</strong>                              ------install git
- name: Update web servers
  hosts: web
  vars:
    myname: gitinstalled
    age: "18"
    packagename: github
    servicename: github
  vars_files:
    - "vars.yaml"
  vars_prompt:
    - name: "version"
      prompt: "Which version Do you want to install?"
      private: no

<strong>playbook-5:gropinsidegroup </strong>                            ----create group in another group with /bin/bash
- name: Deploying user
  hosts: web

  tasks:
  - name: create user
    user:
      name: deploy-user

      shell:/bin/bash
      group: deploy

<strong>playbook-6:httpd service</strong>                                 ------enable http service
- name: Starting the service
  hosts: webservers

  tasks:
  - name: start service
    service:
      name: httpd

      state: started

<strong>playbook-7:createfile  </strong>                                       ----create dummy index.html file
- name: Initiating File Creation
  hosts: webservers

  tasks:
  - name: creating a file
    copy:
      src: index.html

      dest: index1.html

<strong>playbook-8:copyfile</strong>                                          ------copy second.html 
- name: Copying File
  hosts: webservers

  tasks:
  - name: copy a file
    copy:
      src: seecond.html

      dest: /var/www/html/second.html

Program 1 – Write a Ansible Adhoc Commands to create a group called “deploy“:

##   $ ansible all -m ansible.builtin.user -a "name=deploy password=<crypted password here>"

          (or)

##   $ ansible all -m ansible.builtin.user -a "name=deploy state=absent"

How to verify?
$ more /etc/ansible/group | grep 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 all -m ansible.builtin.user -a"name=deploy-user shell=/bin/bash group=deploy"

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

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

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


(localhost is RHEL/centos)

How to verify?

which httpd

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

$  ansible localhost -m service -a"name=httpd state=present"

how to verify?

$ ps -eaf | grep httpd

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 destination=/var/www/html/index.html"  

(should create a empty index.html)

How to verify?
curl http://x.x.x.x:80(ip of localhost)

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=index.html destination=/var/www/html/index.html"

(should create a empty index.html)

How to verify?

curl http://x.x.x.x/second.html(ip of localhost)

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

https://docs.ansible.com/ansible/2.9/modules/modules_by_category.html ——-website to install packages and etc..

 name: this playbook install pacakges
  hosts: webservers 
  become: true
  tasks:
  - name: install package
    yum: 
    #      name: ['git', 'make', 'gcc', 'wget', 'telnet', 'gzip'] 
      name: "{{ item }}"
      state: installed
    with_items: 
      - git
      - make
      - gcc
      - wget
      - telnet
      - gzip

(or) $ ansible all -m ansible.builtin.git -a"name=git"

How to verify?
$ which git
$ which 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"

$ ls

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

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

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

*normally service is used to balance traffic among pods in a cluster .this can be done with the help of load balancer

*enables network access from either within the cluster or between external processes and the service.

TYPES OF SERVICE:

ClusterIP :only accessible from within the cluster

NodePort:expose via a port on each node IP’s and can be accessed from outside

LoadBalancer:via cloud

ExternalName:map to predefined namefield

Use Of Service named Kubernetes in default Namespace:

*Used to forward the request to the master(APIServer) So all the requests to the Kubernetes default service from the cluster will be routed to the configured Endpoint IP.

service work process:

That has proxy to be configured to forward to the resources

create a service

describe the service and you can see there is no endpoint

Inorder to enable endpoint: edit in a way that label selector at the load balancer should match the label selector of the pod

then you can see endpoints.

Compiled language:

*translators that generate machine code from source code directly.

example :c, Fortran ,COBOL

Interpreted language:

*It is one where the instructions are not directly executed by the target machine, but instead read and executed by some other program.

example: Perl, Python and MATLAB.

Declarative language:

*High level language where desire is specified in simple terms

*specifies what to do rather how to do

example:JSON,YAML,

example:JSON,YAML,

example: JSON, YAML, Erlang.

ADVANTAGES OF DECLARATIVE LANGUAGE:

*high level of abstraction(complex programs in a compressed form)

*maintenance can be performed independently of application development. 

*Easy optimization as implementation is controlled by an algorithm

DISADVANTAGES:

*Hard to understand by people who gains new access to it

*Hard to take characteristics of individual applications into account during programming

*is the smallest building block. Within a cluster, a pod represents a process that’s running

*A Pod  is a group of one or more containers with shared storage and network resources

*is in worker node there can be many pods and each pod has one or more containers

*instantiated by kubelet

*containers share same IP address

*ATOMIC UNIT OF SCHEDULING

*pod is running as long as all the containers inside pod is running (must)

*all namespaces assigned to pod are available to all container

*two inside pod they are main container and side container

*scaling is easy

*communicate outside through pod IP address .

Types of POD:

• Single-container-per-pod.
• Multi-container-pod.

INSIDE POD:

*one or more application containers share same IP address which are relatively tightly coupled. 

POD LIFECYCLE:

*Pending state

*Running state

*Succeeded state

*Failed state

#an open-source container orchestration platform

# enables the operation of an elastic web server framework for cloud applications.

Why Kubernetes:

#It allows us to manage containers in an efficient way

#easy container scaling across many servers in a cluster.

Kubernetes Architecture:

# offers a loosely coupled mechanism for service discovery across a cluster.

# A Kubernetes cluster has many nodes .each of the compute nodes runs a container runtime like Docker along with an agent, kubelet, which communicates with the control plane.

# The control plane is responsible for managing the overall cluster, exposing the application program interface (API), and for scheduling the initiation and shutdown of compute nodes based on a desired configuration.

Componenets:

Kubernetes API Server:

#front end of the control plane where we interact

Kubernetes Scheduler:

#assigns received requests to heathy nodes from API server

Kubernetes Controller Manager:

# obtain the desired state from the API Server.

etcd:

#storage of api

Container Runtime Engine:

The container runtime pulls images from a container image registry and starts and stops containers. A 3^rd party software or plugin, such as Docker, usually performs this function.

Kube-proxy service:

# assign IP address to each node, implements local iptables and rules to handle routing and traffic load balancing.

Pods:

#A pod is the smallest element of scheduling in Kubernetes.

#it has all container services running within it which can’t be accessed.

Working with images:

#A container image is a ready-to-run software package, containing everything needed to run an application:

#By design, a container is immutable: you cannot change the code of a container that is already running.

For more information:https://kubernetes.io/