+
+## Continuous Integration
+
+The goal of continuous integration (CI) is to quickly produce code that works. Successful CI means the changes to an app are built, tested and merged regularly. This integration can happen many times a day, and it usually involves automated test cases and a well-defined build sequence that minimizes errors. The main focus when using CI methodologies should be:
+1. Smaller code: reduce the size of your contributions to the main branch, and make them instead more frequently. This will make it easy to detect bugs early and reduce conflicts with other contributions. Smaller integrations also mean test cases can run faster and your code becomes available to others that might be impacted by your feature.
+2. Automated testing: Although there are CI "pipelines" that do not use automated testing, in practice automation vastly outweighs the benefits of manual testing. If a developer is integrating code several times a day, manual testing becomes troublesome, inconsistent and generally a waste of the developer's productivity.
+
+## Continuous Delivery
+
+This term is often used interchangeably with Continuous Deployment, but it can be nuanced. Usually Continuous Delivery will refer to how a developer is constantly *delivering* code that has already been tested for bugs. This does not mean the integrated code will be used in a live production environment. With Continous Delivery the process of pushing code from the developers' environment to the repository is automated, reducing the number of or eliminating the manual steps required.
+
+## Continuous Deployment
+
+Although it varies from team to team, Continuous Deployment will refer to code that, when integrated, is also deployed automatically to the live production site of the app. The reason this and Continuous Delivery are often both included in CD is because typical CI/CD pipelines will include both, and they both complement each other.
+
+## Elements of a CI/CD pipeline
+
+RedHat provides the following definitions in their article [What is a CI/CD pipeline?](https://www.redhat.com/en/topics/devops/what-cicd-pipeline):
+
+The steps that form a CI/CD pipeline are distinct subsets of tasks grouped into what is known as a pipeline stage. Typical pipeline stages include:
+
+* Build - The stage where the application is compiled.
+* Test - The stage where code is tested. Automation here can save both time and effort.
+* Release - The stage where the application is delivered to the repository.
+* Deploy - In this stage code is deployed to production.
+* Validate and check compliance - The steps to validate a build are determined by the needs of your organization. Image security scanning tools, like Clair, can ensure the quality of images by comparing them to known vulnerabilities (CVEs).
+
+
diff --git a/Cloud_providers/AWS/aws.md b/Cloud_providers/AWS/aws.md
new file mode 100644
index 00000000..8154074e
--- /dev/null
+++ b/Cloud_providers/AWS/aws.md
@@ -0,0 +1,148 @@
+# Amazon Web Services (AWS) Concepts
+
+Amazon Web Services (AWS) is a leading cloud service provider that offers a wide range of cloud computing services. Below are some fundamental concepts to understand when working with AWS:
+
+## 1. Regions and Availability Zones
+
+- **Region:** A geographic area that consists of multiple Availability Zones. Each AWS region is a separate geographic area, isolated from others, and is designed to provide high availability and low latency.
+- **Availability Zone (AZ):** A data center or facility within an AWS region. AZs are interconnected but physically separate from each other, providing redundancy and fault tolerance.
+
+## 2. EC2 (Elastic Compute Cloud)
+
+- **EC2 Instance:** Virtual machines that you can rent on AWS. They vary in terms of computing power, memory, and storage capacity to meet different application requirements.
+- **AMI (Amazon Machine Image):** A pre-configured virtual machine image used to create EC2 instances.
+- **Security Groups:** Virtual firewalls that control inbound and outbound traffic to EC2 instances.
+
+## 3. S3 (Simple Storage Service)
+
+- **S3 Bucket:** A container for storing data objects (files) in S3. Buckets have unique names and are used to organize and manage data.
+- **Objects:** The data files stored in S3 buckets. Each object consists of data, a key (unique within a bucket), and metadata.
+
+## 4. IAM (Identity and Access Management)
+
+- **IAM User:** An individual or system that interacts with AWS resources. Each user has its own set of credentials and permissions.
+- **IAM Role:** A set of permissions that define what actions an entity can perform on AWS resources. Roles can be assumed by EC2 instances, Lambda functions, etc.
+- **Policies:** JSON documents that define permissions for users, groups, and roles.
+
+## 5. RDS (Relational Database Service)
+
+- **RDS Instance:** Managed relational database instances (e.g., MySQL, PostgreSQL, Oracle) that are scalable and highly available.
+- **DB Snapshots:** Point-in-time backups of an RDS instance, used for data recovery and replication.
+- **Multi-AZ Deployment:** A configuration that replicates the database across multiple Availability Zones for high availability.
+
+## 6. VPC (Virtual Private Cloud)
+
+- **VPC:** A logically isolated section of the AWS cloud where you can launch AWS resources. It provides control over network configuration and security.
+- **Subnet:** A range of IP addresses in your VPC. Subnets are associated with specific Availability Zones.
+- **Route Table:** A set of rules that determine where network traffic is directed within a VPC.
+
+## 7. Lambda
+
+- **AWS Lambda:** A serverless computing service that lets you run code in response to events without provisioning or managing servers.
+- **Event Sources:** Triggers that invoke Lambda functions, such as API Gateway, S3, or CloudWatch Events.
+- **Function:** The code you want to execute when a Lambda is triggered.
+
+## 8. Elastic Load Balancing (ELB)
+
+- **ELB:** A service that distributes incoming traffic across multiple EC2 instances for improved availability and fault tolerance.
+- **Load Balancer Types:** Classic Load Balancer, Application Load Balancer (ALB), Network Load Balancer (NLB).
+## 9. Amazon Route 53
+
+- **Amazon Route 53:** Route 53 is a scalable domain name system (DNS) web service that allows you to register domain names and route internet traffic to the appropriate resources, such as EC2 instances, S3 buckets, or load balancers.
+
+- **DNS Record Types:** Route 53 supports various DNS record types, including A records (for IPv4 addresses), AAAA records (for IPv6 addresses), CNAME records (for aliasing), MX records (for mail routing), and more.
+
+- **Health Checks:** You can configure Route 53 to perform health checks on your resources and automatically route traffic away from unhealthy endpoints to maintain high availability.
+
+## 10. AWS Elastic Beanstalk
+
+- **AWS Elastic Beanstalk:** Elastic Beanstalk is a Platform-as-a-Service (PaaS) that simplifies the deployment and management of web applications. It automatically handles infrastructure provisioning, capacity scaling, and application monitoring.
+
+- **Supported Platforms:** Elastic Beanstalk supports various programming languages and web frameworks, including Java, .NET, PHP, Node.js, Python, Ruby, and more.
+
+- **Customization:** While Elastic Beanstalk simplifies deployment, you can still customize the environment by specifying configuration files and settings.
+
+## 11. ECS (Elastic Container Service) and EKS (Elastic Kubernetes Service)
+
+- **ECS:** ECS is a container orchestration service that allows you to run, stop, and manage Docker containers on a cluster of EC2 instances. It simplifies the deployment of containerized applications.
+
+- **EKS:** EKS is a managed Kubernetes service that makes it easier to deploy, manage, and scale containerized applications using Kubernetes.
+
+- **Containers:** Both ECS and EKS are designed for container management and can scale your applications automatically based on demand.
+
+## 12. Amazon CloudWatch
+
+- **Amazon CloudWatch:** CloudWatch is a monitoring and observability service that collects and tracks metrics and logs from various AWS resources, applications, and services.
+
+- **Alarms:** You can set up alarms in CloudWatch to automatically trigger actions or notifications when specified thresholds are breached.
+
+- **Logs and Insights:** CloudWatch Logs allows you to collect, monitor, and store log data from your applications, while CloudWatch Logs Insights helps you analyze and gain insights from log data.
+
+## 13. Amazon Elasticsearch Service
+
+- **Amazon Elasticsearch Service:** This is a managed Elasticsearch service that makes it easy to deploy, operate, and scale Elasticsearch clusters for searching, analyzing, and visualizing data in real-time.
+
+- **Kibana Integration:** Amazon Elasticsearch Service integrates with Kibana for data visualization and exploration.
+
+- **Security and Access Control:** Elasticsearch Service provides security features such as encryption, access control, and VPC support.
+
+## 14. AWS CloudFormation
+
+- **AWS CloudFormation:** CloudFormation is an Infrastructure-as-Code (IaC) service that allows you to define and provision AWS infrastructure resources in a declarative template. You can create, update, and delete resources as a single unit.
+
+- **Templates:** CloudFormation templates are written in JSON or YAML and can describe a wide range of AWS resources and their relationships.
+
+- **Stacks:** Stacks are sets of AWS resources created and managed together using CloudFormation templates.
+
+## 15. Serverless Application Model (SAM)
+
+- **AWS SAM:** SAM is an open-source framework for building serverless applications. It extends AWS CloudFormation to simplify the deployment of serverless resources like AWS Lambda functions, API Gateway, and DynamoDB tables.
+
+- **Local Testing:** SAM allows you to test your serverless applications locally before deploying them to the AWS cloud.
+
+- **Resource Definitions:** SAM templates define serverless resources using a simplified syntax, making it easier to work with serverless applications.
+## 16. Amazon VPC Peering
+
+- **VPC Peering:** Amazon VPC Peering allows you to connect two Amazon Virtual Private Clouds (VPCs) and route traffic between them using private IP addresses. It enables communication between resources in different VPCs as if they were on the same network.
+
+- **Transitive Peering:** VPC peering is not transitive, meaning if VPC A is peered with VPC B and VPC B is peered with VPC C, VPC A cannot directly communicate with VPC C. Additional peering connections or a transit VPC may be required.
+
+## 17. Amazon EFS (Elastic File System)
+
+- **Amazon EFS:** EFS is a managed file storage service that provides scalable, highly available, and durable file storage for EC2 instances. It can be accessed concurrently by multiple instances, making it suitable for shared file systems.
+
+- **Mount Targets:** EFS uses mount targets in your VPC to make the file system available to EC2 instances. You can mount an EFS file system on multiple instances simultaneously.
+
+## 18. Amazon SNS (Simple Notification Service)
+
+- **Amazon SNS:** SNS is a fully managed messaging service that enables you to send messages or notifications to a distributed set of recipients via various communication protocols (e.g., email, SMS, HTTP, Lambda).
+
+- **Publish-Subscribe Model:** SNS follows a publish-subscribe model, allowing multiple subscribers to receive messages published to specific topics. It is often used for event-driven communication.
+
+## 19. AWS Direct Connect
+
+- **AWS Direct Connect:** Direct Connect provides dedicated network connections from your on-premises data centers to AWS. It offers a more reliable, lower-latency connection compared to the public internet for data transfer and accessing AWS services.
+
+- **Virtual Interfaces:** Direct Connect allows you to create virtual interfaces (private or public) to connect to AWS services or your VPCs.
+
+## 20. AWS Organizations
+
+- **AWS Organizations:** AWS Organizations is a service for managing multiple AWS accounts centrally. It enables you to create and manage member accounts, apply policies, and consolidate billing and cost management.
+
+- **Consolidated Billing:** With AWS Organizations, you can consolidate billing across multiple AWS accounts to simplify cost tracking and management.
+
+- **Service Control Policies (SCPs):** SCPs allow you to set fine-grained permissions and control access to AWS services and resources within member accounts.
+
+## 21. AWS Lambda Layers
+
+- **AWS Lambda Layers:** Layers are a distribution mechanism for libraries, custom runtimes, and other function dependencies in AWS Lambda. You can include common code or resources across multiple Lambda functions.
+
+- **Versioning and Publishing:** Layers can be versioned and published, allowing you to manage updates and share code or data consistently among your functions.
+
+## 22. AWS Glue
+
+- **AWS Glue:** AWS Glue is a fully managed ETL (Extract, Transform, Load) service that simplifies the process of preparing and loading data for analytics. It can automatically discover, catalog, and transform data from various sources.
+
+- **Data Catalog:** Glue Data Catalog acts as a central metadata repository, making it easier to search and discover data for analytics and reporting.
+
+- **ETL Jobs:** Glue allows you to create and run ETL jobs using Python or Scala, making it accessible for data engineers and analysts.
diff --git a/Cloud_providers/AWS/basics.md b/Cloud_providers/AWS/basics.md
new file mode 100644
index 00000000..94d17250
--- /dev/null
+++ b/Cloud_providers/AWS/basics.md
@@ -0,0 +1,224 @@
+## AWS
+
+Amazon Web Services (AWS) is a versatile cloud computing platform offering a wide array of services and tools for businesses and individuals. Here, we'll delve into fundamental concepts, troubleshooting IAM, essential commands, and valuable tips and tricks to empower your AWS journey.
+
+### Basic Concepts
+
+#### [Amazon Resource Names](https://docs.aws.amazon.com/general/latest/gr/aws-arns-and-namespaces.html)
+
+Amazon Resource Names (ARNs) are unique identifiers for AWS resources, essential for unambiguous resource specification. ARNs are utilized in IAM policies, Amazon RDS tags, and API calls.
+
+#### [Amazon EC2 (Elastic Compute Cloud ):](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/concepts.html)
+
+Amazon EC2 provides resizable compute capacity in the cloud. It allows you to run virtual servers for various purposes, ranging from web applications to complex data processing.
+
+#### [Amazon S3 (Simple Storage Service):](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/AmazonS3.html)
+
+Amazon S3 is an object storage service that offers industry-leading scalability, data availability, security, and performance. It is used to store and retrieve any amount of data from anywhere on the web.
+
+#### [Amazon RDS (Relational Database Service)](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/Welcome.html)
+
+Amazon RDS simplifies the setup, operation, and scaling of a relational database. It supports several database engines, including MySQL, PostgreSQL, and SQL Server, making it easier to set up, operate, and scale a relational database in the cloud.
+
+#### [Amazon VPC (Virtual Private Cloud)](https://docs.aws.amazon.com/vpc/latest/userguide/what-is-amazon-vpc.html)
+
+Amazon VPC lets you provision a logically isolated section of the AWS Cloud where you can launch AWS resources in a virtual network that you define. You have complete control over your virtual networking environment.
+
+#### [Auto Scaling](https://docs.aws.amazon.com/autoscaling/ec2/userguide/what-is-amazon-ec2-auto-scaling.html)
+
+Auto Scaling allows you to automatically adjust the number of compute resources in your Auto Scaling group. It helps you ensure that you have the correct number of Amazon EC2 instances available to handle the load for your application.
+
+#### [Elastic Load Balancing ](https://docs.aws.amazon.com/elasticloadbalancing/latest/userguide/what-is-load-balancing.html)
+
+Elastic Load Balancing automatically distributes incoming application traffic across multiple targets, such as Amazon EC2 instances, containers, and IP addresses, within one or more availability zones.
+
+#### [Amazon DynamoDB](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/Introduction.html)
+
+Amazon DynamoDB is a fully managed NoSQL database service that provides fast and predictable performance with seamless scalability. It is a key-value and document database that delivers single-digit millisecond performance at any scale.
+
+
+#### [AWS Lambda](https://docs.aws.amazon.com/lambda/?icmpid=docs_homepage_featuredsvcs)
+
+AWS Lambda lets you run code without provisioning or managing servers. You can run your code in response to events and automatically manage compute resources, making it easy to build applications that respond quickly to new information.
+
+
+#### [Amazon CloudWatch](https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/cloudwatch_architecture.html)
+
+Amazon CloudWatch monitors your AWS resources and the applications you run on the cloud. You can use CloudWatch to collect and track metrics, collect and monitor log files, set alarms, and automatically react to changes in your AWS resources.
+
+#### [AWS CloudFormation](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/Welcome.html)
+
+AWS CloudFormation provides a common language for describing and provisioning all the infrastructure resources in your cloud environment. It allows you to use a simple YAML or JSON file to model and provision, in an automated and secure manner, all the resources needed for your applications.
+
+#### [Identity and Access Management (IAM)](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_identifiers.html)
+
+IAM enables secure management of access to AWS services. Through users, groups, and roles, IAM policies define permissions, evaluated when users make requests.
+
+#### [IAM Policies](https://docs.aws.amazon.com/IAM/latest/UserGuide/troubleshoot_policies.html)
+
+Policies, entities within AWS, define user and resource permissions. AWS assesses policies during requests, ensuring appropriate access control.
+
+ #### [AWS Troubleshooting IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/troubleshoot.html)
+
+Troubleshooting IAM involves meticulous policy analysis. Ensure policies grant required permissions. Use AWS Policy Simulator to simulate policy effects, aiding policy refinement.
+
+These concepts are fundamental to understanding how AWS services work together to build scalable, reliable, and secure cloud applications and infrastructures.
+
+
+### Essential Commands
+
+1. **Configures your AWS CLI with your AWS access key, secret key, default region, and output format.**
+ ``` aws configure ```
+
+2. **Displays information about available AWS CLI commands and their usage.**
+ ```aws help```
+
+### Identity and Access Management (IAM) Commands:
+
+1. **Creates a new IAM user.**
+ ```aws iam create-user```
+
+2. **Creates a new IAM group.**
+ ```aws iam create-group```
+
+3. **Creates a new IAM role.**
+ ```aws iam create-role```
+
+4. **Attaches an IAM policy to a user.**
+ ```aws iam attach-user-policy```
+
+7. **Attaches an IAM policy to a group.**
+ ```aws iam attach-group-policy```
+
+8. **Attaches an IAM policy to a role.**
+ ```aws iam attach-role-policy```
+
+9. **Lists all IAM users in your account.**
+ ```aws iam list-users```
+
+10. **List all IAM groups in your account**
+ ```aws iam list-groups```
+
+11. **Lists all IAM roles in your account.**
+ ```aws iam list-roles```
+
+### EC2 (Elastic Compute Cloud) Commands:
+
+1. **Lists all EC2 instances in your account.**
+ ```aws ec2 describe-instances```
+
+2. **Launches a new EC2 instance.**
+ ```aws ec2 run-instances```
+
+3. **Starts an existing EC2 instance.**
+ ```aws ec2 start-instances```
+
+4. **Stops a running EC2 instance.**
+ ```aws ec2 stop-instances```
+
+5. **Terminates an EC2 instance.**
+ ```aws ec2 terminate-instances```
+
+### S3 (Simple Storage Service) Commands:
+
+1. **Lists all S3 buckets in your account.**
+ ```aws s3 ls```
+
+2. **Creates a new S3 bucket.**
+ ```aws s3 mb```
+
+3. **Copies files or directories to/from S3.**
+ ```aws s3 cp```
+
+4. **Synchronizes files and directories to S3.**
+ ```aws s3 sync```
+
+5. **Deletes files or objects from S3.**
+ ```aws s3 rm```
+
+### CloudFormation Commands:
+
+1. **Creates a new CloudFormation stack.**
+ ```aws cloudformation create-stack```
+
+2. **Updates an existing CloudFormation stack.**
+ ```aws cloudformation update-stack```
+
+3. **Deletes a CloudFormation stack.**
+ ```aws cloudformation delete-stack```
+
+### Lambda Commands:
+
+1. **Lists all Lambda functions in your account.**
+ ```aws lambda list-functions```
+
+2. **Creates a new Lambda function.**
+ ```aws lambda create-function```
+
+3. **Invokes a Lambda function.**
+ ```aws lambda invoke```
+
+These commands are just the basics and cover a wide range of AWS services.
+For specific command options and syntax, you can always refer to the official AWS CLI documentation or use the `aws help` command followed by the service name, e.g., `aws ec2 help`.
+
+#### Kubernetes Contexts
+
+Managing Kubernetes contexts is vital for multiple cluster management:
+
+Get available contexts:
+
+``` kubectl config get-contexts ```
+
+Switch context:
+
+``` kubectl config use-context Docker Basic Commands
+ +## Build Images + +- Create image using current directory’s Dockerfile+ ``` docker build -t image-name . ``` + +- List images
+ ``` docker images ``` + +
+ +## Running Container + +- Create new container from specified image
+ ``` docker run image-name ``` + +- Assign a name to the container
+ ``` docker run --name nick-name image-name ``` + +- Run image with an entry point | override existing entrypoint
+ ```docker run image-name cmd```
+ ```docker run image-name --entrypoint cmd``` + +- Run image in interactive mode
+ ``` docker run -it image-name ``` + +- Run image in detached mode
+ ``` docker run -d image-name ``` + +- Run image mapping container's port to the host
+ ``` docker run -p host-port:container-port image-name ``` + +
+ +## Managing Containers + +- List running containers
+ ``` docker ps ``` + +- List all containers
+ ```docker ps -a``` + +- Stop one or more running containers
+ ```docker stop containerId``` + +- Start one or more stopped containers
+ ```docker start containerId``` + +- Fetch the logs of a container
+ ```docker logs containerId``` + +- Fetch and follow log output of a container
+ ```docker logs -f containerId``` + +- Run a command in a running container in interactive mode
+ ```docker exec -it containerId cmd``` + +- Copy files/folders from container to local filesystem
+ ``` docker cp containerId:/workdir/file.ext .``` + +- Copy files/folders from local filesystem to container
+ ``` docker cp file.ext containerId:/workdir/``` + +- Remove container
+ ```docker rm containerId``` + +- Remove running container
+ ```docker rm -f containerId``` + +- Remove all running and stopped containers
+ ```docker rm -f $(docker ps -a -q)``` + +
+ + +## Persistant data using Volumes + +- Creates a new volume that containers store data
+ ```docker volume create volume-name``` + +- Display detailed information on one or more volumes
+ ```docker volume inspect volume-name``` + +- List volumes
+ ```docker volume ls``` + +- Create a volume and then configure the container to use it
+ ``` docker run -v volume-name:/dir/dir container-name``` + +- Create mapping between dir in host and container
+ ``` docker run -v $(pwd):/workdir container-name``` + + + + +
+ +## Managing Images + +#### Tagging Images + +- Create tag to the image while building
+ ``` docker build -t image-name:tag . ``` + +- Create tag to the image after building
+ ``` docker image tag src-image:latest dst-image:tag ``` + +#### Saving & Loading Images + +- Save one or more images to a tar archive
+ ``` docker image save -o image-name.tar image-name:tag ``` + +- Load an image from a tar archive
+ ``` docker image load -i image-name.tar ``` + +#### Remove Images + +- Remove one or more images
+ ``` docker image rm image-name ```
+ ``` docker rmi image-name ``` + +- Remove all images
+ ``` docker system prune -a ``` + +- Remove all stopped containers
+ ``` docker container prune ``` + +- Remove all dangling images
+ ``` docker image prune ``` + +- Remove all unused containers, networks, dangling and unreferenced images
+ ``` docker system prune ``` diff --git a/Container-orchestration/Docker/docker-commands.md b/Container-orchestration/Docker/docker-commands.md new file mode 100644 index 00000000..aeed4341 --- /dev/null +++ b/Container-orchestration/Docker/docker-commands.md @@ -0,0 +1,229 @@ + +### Docker Build & Run  + +- Create image using this directory’s Dockerfile + +``` docker build -t image-name . ``` + +- Run “image-name” mapping port 8080 to 80 + +``` docker run -p 8080:80 image-name ``` + +- Run “image-name” mapping port 8080 to 80, but in detached mode + +``` docker run -d -p 8080:80 image-name ``` + +- See a list of all running containers + +``` docker ps ``` + +- Gracefully stop the specified container + +``` docker stop
+Most databases use ***Structured Query Language (SQL)*** for writing and querying data. + +## Structured Query Language (SQL) + +**SQL** is a standard language for storing, manipulating and retrieving data in relational databases. SQL was first developed at IBM in the 1970s with Oracle as a major contributor, which led to implementation of the SQL ANSI standard, SQL has spurred many extensions from companies such as IBM, Oracle, and Microsoft. Although SQL is still widely used today, new programming languages are beginning to appear + +## Evolution Of Database + + **1.Flat Files (1970s-1990s)** : Flat files database is a database that stores information in a single file or table. In text file, every line contains one record where fields either have fixed length or they are separated by commas, whitespaces, tabs or any records and they cannot contain multiple tables as well. + + **2.Hierarchical (1970s-1990s)** : As the name indicates, hierarchical database contains data in a hierarchically-arranged data. More Perceptively it can parent can have many children but one child can only have one parent i. e.,; one-to-many relationship. Its hierarchical structure contains levels or segments which are equivalent to the file system’s record type. + + **3.Network database (1970s -1990s)** : The inventor of network model is Charles Bachmann. Unlike hierarchical database model, network database allows multiple parent and child relationships i. e., it maintains many-to many relationship. Network database is basically a graph structure. The network database model was created to achieve three main objectives:
+
-
+ a. To represent complex data relationship more effectively
+ b. To improve the performance of the database.
+ c. To improve a database standard. +
+ {%+ if something %}hello{% endif %}
+
+```
+condition example
+```j2
+{% if lookup('env','DEBUG') == "true" %}
+ CMD ["java", "start-debug"]
+{% else %}
+ CMD ["java", "start"]
+{% endif %}
+```
+
+### directives for loop, for last, loop last
+```
+[
+{% for stream in deployment.streams %}
+ {
+ "stream": "{{ stream.stream_name }}",
+ "classN": "{{ stream.class_name }}",
+ "script": "{{ stream.script_name }}",
+ "sibFolders": [
+ {% for folder in stream.sub_folders %}
+ "{{ folder }}"{% if not loop.last %},{% endif %}
+ {% endfor %}
+ ]
+ }{% if not loop.last %},{% endif %}
+{% endfor %}
+]
+```
+
+## escaping
+just a symbol
+```
+{{ '{{' }}
+```
+bigger piece of code
+```
+{% raw %}
+ -
+ {% for item in seq %}
+
- {{ item }} + {% endfor %} +
 Neil Duncan 📖 |
-  cuzza0 📖 |
-  Adrian Moisey 📖 |
-  Pavel Kozlov 💬 |
-  Milap Neupane 💻 ✅ |
-  john 📖 |
+  Neil Duncan 📖 |
+  cuzza0 📖 |
+  Adrian Moisey 📖 |
+  Pavel Kozlov 💬 |
+  Milap Neupane 💻 ✅ |
+  john 📖 |
+  Jobin George 📖 |
+
 tsyr2ko 📖 |
+  Víctor Nieves Sánchez 📖 |
+  Frank 📖 |
+  Asad Mansoor 📖 |
+  Stanislas 📖 |
+  Rodrigo Fazenda 📖 |
+  Nikolay Stanchev 📖 |
+ ||||||
 Meet Patel 💻 |
+  shenxianpeng 📖 |
+  Umang Dobariya 📖 |
+  Rakesh .B 📖 |
+  Federico Garcia-Lorca 📖 |
+  Dave 📖 |
+  Brahmajit 📖 💻 |
+ ||||||
 Milind Chawre 💻 |
+  Leandro Nunes 💻 |
+  Yashika Gupta 💻 |
+  Victor da Silva 💻 |
+  errazudin ishak 💻 |
+  Niraj 💻 📖 |
+  petemadis 📖 |
+ ||||||
 Onaopemipo 📖 |
+  mygwen 📖 |
+  peachybutt 📖 |
+  Jenisten Xavier 📖 |
+  sahid1486 🖋 💻 |
+  Thorsten Hans 🖋 💻 |
+  yenyl 📖 |
+ ||||||
 Wasisto 📖 |
+  Muskan Rathore 📖 |
+  Ebennetteng 📖 |
+  ShvetaVasisht 💻 |
+  Franciosi 💻 |
+  Eslam Adel 📖 |
+  Mahmood Ahmad 📖 |
+ ||||||
 Diego Arostegui 💻 |
+  relativvv 💻 |
+*********************************************
## License
This project is licensed under the MIT License - Copyright (c) 2019 Tikam Alma
diff --git a/Servers/Apache/Readme.md b/Servers/Apache/Readme.md
new file mode 100644
index 00000000..b7d6883a
--- /dev/null
+++ b/Servers/Apache/Readme.md
@@ -0,0 +1,6 @@
+# Apahe2 Server
+
+- Deployment
+- Configurations
+- Mods
+- Security
\ No newline at end of file
diff --git a/Servers/Apache/configs/templates/deploy-django.md b/Servers/Apache/configs/templates/deploy-django.md
new file mode 100644
index 00000000..5e95504f
--- /dev/null
+++ b/Servers/Apache/configs/templates/deploy-django.md
@@ -0,0 +1 @@
+## Deploy Django
\ No newline at end of file
diff --git a/Servers/Apache/configs/templates/deploy-node-server.md b/Servers/Apache/configs/templates/deploy-node-server.md
new file mode 100644
index 00000000..2368ca8c
--- /dev/null
+++ b/Servers/Apache/configs/templates/deploy-node-server.md
@@ -0,0 +1 @@
+## Deploy Node server
\ No newline at end of file
diff --git a/Servers/Apache/configs/templates/deploy-static-sites.md b/Servers/Apache/configs/templates/deploy-static-sites.md
new file mode 100644
index 00000000..a4dfca13
--- /dev/null
+++ b/Servers/Apache/configs/templates/deploy-static-sites.md
@@ -0,0 +1 @@
+## Deploy Static Websites
\ No newline at end of file
diff --git a/Servers/Apache/configs/templates/django.no-ssl.domain.conf b/Servers/Apache/configs/templates/django.no-ssl.domain.conf
new file mode 100644
index 00000000..b571f2ad
--- /dev/null
+++ b/Servers/Apache/configs/templates/django.no-ssl.domain.conf
@@ -0,0 +1,44 @@
+# -----------------------------------------------------------------------
+# | Config file for example.com host to deploy django server via apache2 |
+# -----------------------------------------------------------------------
+# When you use daemon mode, the number of processes and threads is static. This is one of the immediate benefits of using daemon mode.
+# Specifically, that process management is more predictable. One of the big problems with using embedded mode is that Apache can decide to create additional processes or kill off existing ones.
+# For a web application with large startup costs this is not a good idea as you could suddenly see increased CPU usage due to more processes being started right at the time you don't need it such as when a throughput spike occurs.
+# This can actually cause performance to degrade in the short term rather than improve.
+
+#Use Daemon Mode by Restricting WSGIRestrictEmbedded On
+WSGIRestrictEmbedded On
+
+