yaml  
- name: Установить Nginx  
  apt:  
    name: nginx  
    state: present  
  tags: install  

- name: Перезапустить Nginx  
  service:  
    name: nginx  
    state: restarted  
  tags: restart  

sh  
ansible-playbook playbook.yml --tags install  

sh  
ansible-playbook playbook.yml --tags restart  

yaml  
- hosts: all  
  roles:  
    - { role: nginx, tags: web }  
    - { role: database, tags: db }  

sh  
ansible-playbook playbook.yml --tags db  

sh  
ansible-playbook playbook.yml --skip-tags restart  

FROM ubuntu:20.04
RUN useradd -m myuser
USER myuser
CMD ["myapp"]     

docker run --user 1000:1000 myapp

yaml  
apiVersion: v1  
kind: Pod  
metadata:  
  name: my-app  
spec:  
  containers:  
  - name: app  
    image: my-app:latest  
    resources:  
      requests:  
        cpu: "500m"   # Минимально 0.5 CPU  
        memory: "256Mi" # Минимально 256MB RAM  
      limits:  
        cpu: "1000m"  # Максимально 1 CPU  
        memory: "512Mi" # Максимально 512MB RAM  

nginx  
upstream backend {  
  server app1:5000;  
  server app2:5000;  
}  
server {  
  listen 80;  
  location / {  
    proxy_pass http://backend;  
  }  
}  

hcl  
resource "aws_lb" "example" {  
  name               = "my-load-balancer"  
  internal           = false  
  load_balancer_type = "application"  
  security_groups    = [aws_security_group.lb_sg.id]  
}  

yaml  
apiVersion: autoscaling/v2beta2  
kind: HorizontalPodAutoscaler  
metadata:  
  name: my-app-hpa  
spec:  
  scaleTargetRef:  
    apiVersion: apps/v1  
    kind: Deployment  
    name: my-app  
  minReplicas: 2  
  maxReplicas: 10  
  metrics:  
  - type: Resource  
    resource:  
      name: cpu  
      target:  
        type: Utilization  
        averageUtilization: 70  

hcl  
resource "aws_autoscaling_group" "example" {  
  min_size             = 2  
  max_size             = 10  
  desired_capacity     = 2  
  launch_configuration = aws_launch_configuration.example.name  
}  

yaml  
apiVersion: networking.k8s.io/v1  
kind: IngressClass  
metadata:  
  name: nginx  
spec:  
  controller: k8s.io/ingress-nginx  

yaml  
apiVersion: networking.k8s.io/v1  
kind: Ingress  
metadata:  
  name: my-ingress  
spec:  
  ingressClassName: nginx  
  rules:  
  - host: example.com  
    http:  
      paths:  
      - path: /  
        pathType: Prefix  
        backend:  
          service:  
            name: my-service  
            port:  
              number: 80  

yaml  
apiVersion: networking.k8s.io/v1  
kind: Ingress  
metadata:  
  name: my-ingress  
  annotations:  
    kubernetes.io/ingress.class: "nginx"  
spec:  
  rules:  
  - host: example.com  
    http:  
      paths:  
      - path: /  
        pathType: Prefix  
        backend:  
          service:  
            name: my-service  
            port:  
              number: 80  

sh  
docker volume create mydata  
docker run -d -v mydata:/app/data --name mycontainer ubuntu  

sh  
docker volume rm mydata  

sh  
docker run -d -v /home/user/logs:/app/logs --name mycontainer ubuntu  

sh  
docker run -d --tmpfs /app/cache:size=100m --name mycontainer ubuntu  

json  
GET /logs/_search  
{  
  "query": {  
    "match": { "message": "error" }  
  }  
}  

yaml  
input {  
  file {  
    path => "/var/log/nginx/access.log"  
    start_position => "beginning"  
  }  
}  
filter {  
  grok { match => { "message" => "%{COMBINEDAPACHELOG}" } }  
}  
output {  
  elasticsearch {  
    hosts => ["http://elasticsearch:9200"]  
  }  
}  

  
message: "error" AND @timestamp:[now-24h TO now]  

yaml  
version: "3"  
services:  
  elasticsearch:  
    image: docker.elastic.co/elasticsearch/elasticsearch:8.5.0  
    environment:  
      - discovery.type=single-node  
    ports:  
      - "9200:9200"  

  logstash:  
    image: docker.elastic.co/logstash/logstash:8.5.0  
    depends_on:  
      - elasticsearch  
    volumes:  
      - ./logstash.conf:/usr/share/logstash/pipeline/logstash.conf  
    ports:  
      - "5044:5044"  

  kibana:  
    image: docker.elastic.co/kibana/kibana:8.5.0  
    depends_on:  
      - elasticsearch  
    ports:  
      - "5601:5601"  

promql  
http_requests_total  

promql  
rate(http_requests_total[5m])  

go  
httpRequests := prometheus.NewCounter(  
    prometheus.CounterOpts{  
        Name: "http_requests_total",  
        Help: "Total number of HTTP requests",  
    })  

promql  
node_memory_usage_bytes  

promql  
avg(node_cpu_seconds_total)  

go  
cpuUsage := prometheus.NewGauge(  
    prometheus.GaugeOpts{  
        Name: "cpu_usage_percentage",  
        Help: "Current CPU usage",  
    })  

promql  
http_request_duration_seconds_bucket  

promql  
histogram_quantile(0.95, rate(http_request_duration_seconds_bucket[5m]))  

go  
requestDuration := prometheus.NewHistogram(  
    prometheus.HistogramOpts{  
        Name:    "http_request_duration_seconds",  
        Help:    "Histogram of response time for HTTP requests",  
        Buckets: prometheus.DefBuckets,  
    })  

promql  
http_request_duration_seconds{quantile="0.99"}  

go  
requestSummary := prometheus.NewSummary(  
    prometheus.SummaryOpts{  
        Name:       "http_request_duration_seconds",  
        Help:       "Summary of response time for HTTP requests",  
        Objectives: map[float64]float64{0.5: 0.05, 0.9: 0.01, 0.99: 0.001},  
    })  

sh  
kubectl top nodes  

NAME        CPU(cores)   CPU%   MEMORY(bytes)   MEMORY%  
node-1      500m         25%    2Gi             50%  
node-2      1000m        50%    4Gi             80%  

sh  
kubectl top pods --all-namespaces  

NAMESPACE   POD            CPU(cores)   MEMORY(bytes)  
default     web-app-1      250m         256Mi  
default     web-app-2      300m         512Mi  
monitoring  prometheus-1   600m         1Gi  

sh  
kubectl describe node node-1  

Allocatable:  
  cpu:                4  
  memory:             8Gi  
  pods:               110  

sh  
kubectl describe pod my-pod  

Requests:  
  cpu:     500m  
  memory:  1Gi  
Limits:  
  cpu:     1  
  memory:  2Gi  

promql  
avg(rate(node_cpu_seconds_total[5m])) * 100  

promql  
avg(node_memory_Active_bytes) / avg(node_memory_MemTotal_bytes) * 100