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

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

resource "aws_instance" "first-ec2" {
  ami           = "ami-03d5c68bab01f3496" # us-west-2
  instance_type = "t2.micro"
  
  tags = {
    Name = "godwin"
  }
}

git repo using string variable

provider "github" {
  token = "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" # or `GITHUB_TOKEN`
}

variable "reponame" {
  type = string
  description = "This is for demo of string variable"
  default = "test_repo"
}

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

git repo creating using list variable

variable "gitrepos" {
    type    = list
    default = ["my_test1","my_test2","my_test3"]
    description = "This is for demo of list variable"
}






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
}

• Docker is particularly a container technology while Ansible are tools for configuration management.
• Terraform, created by HashiCorp, provides a syntax to define infrastructure and services that can be hosted either on premises or in the cloud
• ansible and terraform both are opensource.
•  When it comes to Ansible, it’s very similar to Terraform in terms of what you can create with it. For example, you can also create the Azure Resource Group with Terraform.
•  Terraform users define how to create, update, replace and delete resources with a programming language called HashiCorp configuration language (HCL). unlike Terraform, Ansible uses YAML, 
• Ansible works with Python while Docker and Kubernetes work with Go
•  Ansible and Terraform are complementary tools that are commonly used together.
• Use Terraform to create resources and services. Then use Ansible to configure the resources Terraform created.

Terraform Sample code for creating a linux EC2 instance

terraform {
  required_providers {
    aws = {
      source = "hashicorp/aws"
      version = "3.49.0"
    }
    
  }
}


provider "aws" {
  region     = "us-west-2"
  access_key = "" #type access key
  secret_key = "" #type secret key
}


resource "aws_security_group" "allow_tls" {
  name        = "allow_tls"
  description = "Allow TLS inbound traffic"
  vpc_id      = aws_vpc.main.id


}


resource "aws_key_pair" "deployer" {
  key_name   = "deployer-key"
  public_key = "ssh-rsa email@example.com"
}

TOP 10 Jenkins Plugins

• Metrics.
• Mailer.
• pipeline
• SCM API.
• Git.
• GitHub Integration.
• Subversion.
• bootstrapped-multi-test-results-report.
• JUnit.
• green balls
• docker plugin

• sequence of data points collected at regular intervals over a period of time

how prometheus 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

components of prometheus

• prometheus server
• client libraries
• push gateway
• exporters
• alert manager

How does prometheus work

• by pushgateway:-The Pushgateway is an intermediary service which allows you to push metrics from jobs which cannot be scraped
• by prebuilt exporters:- You can write your own exporter/custom collector or use the prebuilt exporters which will collect data from your infrastructure and send it to Prometheus
• by instrumenting:– is the use of a library in an application’s code base in order to expose and update metrics about it for a Prometheus instance to scrape.

tasks:
   - name: create group
     group:
       name:deploy

       state: present

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 user
     user:
       name: deploy-user
       group: deploy
       shell: /bin/bash
    
      

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

- name: Install the package
  ansible.builtin.package:
    name:
      - httpd
    state: latest

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

- name: Install the package
  ansible.builtin.package:
    name:
      - httpd
    state: started

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

---

- hosts: all
  tasks:
  - name: Creating an empty file
    file:
      path: "/var/www/html"
      state: touch

Write a Ansible Playbook to reboot a self machine.

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

ansible all -m ansible.builtin.group -a"name=deploy"

 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"

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

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

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

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

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/index.html"

 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 dest=/var/www/html/second.html" -u root -k

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

ansible all -m ansible.builtin.git -a"name=git"

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"

Write a Ansible commands to reboot a self machine

• An abstract way to expose an application running on a set of Pods as a network service.
• With Kubernetes you don’t need to modify your application to use an unfamiliar service discovery mechanism. Kubernetes gives Pods their own IP addresses and a single DNS name for a set of Pods, and can load-balance across them.

What is the types Services?

• ClusterIP: Exposes the service on a cluster-internal IP. Choosing this value makes the service only reachable from within the cluster. This is the default Service Type
• NodePort: Exposes the service on each Node’s IP at a static port (the NodePort)
• LoadBalancer : Exposes the service externally using a cloud provider’s load balance
• EternalName :which will redirect a request to a domain specified in its external Name parameter:

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

• it is a service which forwards requests to the Kubernetes master .
• So all the requests to the kubernetes.default service from the cluster will be routed to the configured Endpoint IP.

• compiled language :-implementations are typically compilers and not interpreters. eg: java,c,c++
• Interpreter language :- execute instructions directly and freely without compilation. eg: python
• declarative language :- program specifies what is to be done rather than how to do it. expresses logic of a computation

Example of Declarative language

• JSON
• YAML

Pros and Cons of Declarative Language

pros

• short
• efficient code can written
• high level of abstraction

cons

• hard to understand

• atomic units of scheduling
• pods contain one or more containers
• all containers in pod shares the same pod environment.
• pod is running, containers in pod also running

POD lifecycle

• pending -> running -> succeeded/failed

type of PODS

basically two types

• single container pod
• multiple container pod

kubernetes is a open source container orchestration,for container scalability and workload placement,desired stare

Why Kubernetes

for overcomes some challenges

*we can start starting to view data center as a computer

*containers scalability challenge

Kubernetes Architecuture

master:

*kubernet control plane

*high availability(one master goes down other will came)

api server

*front end to control plane

cluster store

*cluster store & configure

*persistent storage

* uses kubctl

controller

*controller of all controllers(node,endpoint….)

scheduler

*assign works to nodes

nodes

*do the works(managing containers)

*it contain kublet,container engine,container proxy

*pods are inside node

kublet

*tracks the state of a pod 

container proxy

*Kube proxy routes traffic coming into a node from the service

How Kubernetes Works