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  

docker pull nginx:latest

docker images

FROM ubuntu:latest
RUN apt update && apt install -y nginx
CMD ["nginx", "-g", "daemon off;"]

docker build -t my-nginx .

docker run -d --name web -p 80:80 nginx

docker ps

docker stop web

git checkout feature-branch

git checkout main
git pull origin main

git checkout feature-branch
git rebase main

   git add <файл>
   

   git rebase --continue
   

git push origin feature-branch --force

ip route add 10.0.0.0/24 via 192.168.1.1

show mac address-table

kubectl taint nodes my-node key=value:NoSchedule

tolerations:
  - key: "key"
    operator: "Equal"
    value: "value"
    effect: "NoSchedule"

spec:
  nodeSelector:
    disktype: ssd

affinity:
  nodeAffinity:
    requiredDuringSchedulingIgnoredDuringExecution:
      nodeSelectorTerms:
        - matchExpressions:
            - key: region
              operator: In
              values:
                - us-east-1

apiVersion: policy/v1
kind: PodDisruptionBudget
metadata:
  name: my-pdb
spec:
  maxUnavailable: 3
  selector:
    matchLabels:
      app: my-app