【devops】04 django-视图和路由

【devops】03 django-orm基础

# wsgi与app通信

WSGI协议，决定了WSGI Server如何调用WSGI App. app是函数, wsgi协议调用 app(environ, start_response)。

1级server完成的事。2级是app被调用之后完成的事

1. 接收数据

2. 解析请求

3. 调用app(environ, start_response)

   - 省略1万行

   -  响应头

   - 响应体

4. 发响应

# 封装app的3种方法

可调用对象：函数，类，类的实例

返回可迭代对象

```
from wsgiref.simple_server import make_server


server = make_server('127.0.0.1',8080,app)
server.serve_forever()
```

## 函数

```
def app(environ, start_response):
    # ..
    start_response('200 OK',[('content-type', 'text/html;charset=utf-8')])
    return [b'a', b'b']
    
    server = make_server('127.0.0.1', 8080, app)
```

## 类

调用之后就实例，实例要是可迭代对象

```
class App():
    def __init__(self,environ, start_response):
        self.environ = environ
        self.start_response = start_response
    def __iter__(self): # 返回迭代器
        self.start_response('200 OK',[('content-type', 'text/html;charset=utf-8')])
        yield  from [b'a', b'b1']
        
        
    server = make_server('127.0.0.1', 8080, App)
```

## 实例

类实例化之后，还可以调用

```
class App():
    def __call__(self,environ, start_response):
        self.environ = environ
        self.start_response = start_response
        self.start_response('200 OK',[('content-type', 'text/html;charset=utf-8')])
        return [b'a', b'b2']
```



environ中包含path, cookie, querystring, post data；

- 路径，cookie, 查询字符，请求体

 environ.get(key) => environ.key; Django, Flask把environ封装成request了，同时也省略了start_response, return可迭代对象。我们只关心生成内容。



# Django

## 概念

就是app，一个大的函数，请求-> 调用app-> get_response进入, 很多中间件处理请求，进入视图（函数，类），响应后再经过中间件

- 函数，返回响应

- django类，as_view ->   实例化，分发 基于请求方法分发到类的属性，再返回响应

- restframework 类, 

  - APIView as_view -> 实例化，加强请求(request.data), 加强响应(序列化), apiexception, 权限，认证。分发请求。基于请求方法分发到类的属性，再返回响应
  - GenericAPIView   抽出属性，列表和详情通用的查询集和序列化器。不包含数据
  - mixin类，  提供通用的方法，与数据库交互。
  - ViewSet     整合列表和详情
  - ModelViewSet, 整合 genericapiview mixin viewset,  as_view -> 实例化，加强请求，响应，异常，权限，认证，限流，基于映射action分发请求方法到不同视图。
  - router, 自动映射 列表 get -> list, post -> create;   详情 get -> retrieve, put -> update , patch -> partial_update , delete -> destroy;

  

## 优点

1. 将模型，视图，控制器分开。MTV(mvc设计模式)
2. 自带orm, template, form, auth核心组件，和组装的后台管理
3. url设计
4. 第3插件,DRF

## 缺点

3.0之前, 同步阻塞。3.0之后异步框架。

 

## 简要步骤

1. 环境 `django 3 -> 3.6-3.9; django 4 -> 3.10+`
2. 项目`django-admin startproject salary ./`
3. 准备数据库 `pip install mysqlclient`, 配置mysql `pip install --only-binary :all: mysqlclient`
4. 应用app  `python manage.py startapp employee`, 注册应用
5. 本地化，时区, 日志配置
6. 数据库配置
7. 创建django表 `python manage.py makemigrations,  python manage.py migrate`

## 虚拟环境

- python 3.8

- pycharm 2021.2.3之后的版本
  - view -> app --> toolbar

## 安装django

| 版本    | python版本 |
| ------- | ---------- |
| 1.11LTS | 2.7-3.7    |
| 2.2LTS  |            |
| 3.2LTS  | 3.6-3.9    |
| 4.2LTS  | 3.10       |

django3兼容2

```bash
pip install django==3.2
# sqlparse, typing-extensions, asgiref, pytz, django
```

```
(djangoT39) C:\Users\rwx\PycharmProjects\djangoT39>pip list
Package    Version
---------- -------
asgiref    3.5.0
Django     3.2
pip        19.0.3
pytz       2022.1
setuptools 40.8.0
sqlparse   0.4.2
```

安装的库

```
lib标准库
site-packages 虚拟环境的包；
- django/bin/django-admin
```



## django脚手架

盖楼的工具`django-admin`

```bash
# 项目脚手架
django-admin startproject salary ./


# 生成结构
salary包
	init 包文件
	asgi 异步
	wsgi 符合wsgi协议的app
	url 路径映射   需要修改
	settings 配置 需要修改
	
当前项目管理工具 manage.py
```

1. ./ 当前目录创建项目，不需要salary/salary
2. 每个项目独立，不要一个大项目，套小项目。每个虚拟环境不一样，这样做之后，所有项目的虚拟环境只能设置一个，所以只这样使用。



## debug模式

settings中，debug仅开发使用

## 数据库

postgresql, mysql, sqlite3, oracle

```
# https://docs.djangoproject.com/en/3.2/ref/settings/#databases

DATABASES = {
    'default': {
        'ENGINE': 'django.db.backends.mysql',
        'NAME': 't39',
        'USER': 'wayne',
        'PASSWORD': 'wayne',
        'HOST': '127.0.0.1',
        'PORT': '3306',
    }
}

```

- 准备t39库, utf8mb4。目前无1张 表。django会建立大量的表。
- 不需要配置pymysql, 由ENGINE管理



django 3.2. 默认model类自增id类型, 默认大整型。

```python
# Default primary key field type
# https://docs.djangoproject.com/en/3.2/ref/settings/#default-auto-field

DEFAULT_AUTO_FIELD = 'django.db.models.BigAutoField'
```



## 准备应用

不同主题不同的代码, 游戏，音乐主题。现在使用项目内的管理工具

```bash
(venv) C:\Users\21923\pycharm_projects\djangot39>python manage.py
django.core.exceptions.ImproperlyConfigured: Error loading MySQLdb module.
Did you install mysqlclient? # pymysql, python重写。mysqlclient扩展，使用C写的。

(venv) C:\Users\21923\pycharm_projects\djangot39>pip install mysqlclient
Successfully installed mysqlclient-2.1.0
```

现在正常，说明数据库正常

```bash
(venv) C:\Users\21923\pycharm_projects\djangot39>python manage.py

Type 'manage.py help <subcommand>' for help on a specific subcommand.

Available subcommands:

[auth]
    changepassword # 修改密码
    createsuperuser # 超级管理员

[contenttypes]
    remove_stale_contenttypes

[django]
    check
    compilemessages
    createcachetable
    dbshell
    diffsettings
    dumpdata
    flush
    inspectdb
    loaddata
    makemessages
    makemigrations # 制作迁移文件
    migrate # 迁移
    sendtestemail
    shell
    showmigrations
    sqlflush
    sqlmigrate
    sqlsequencereset
    squashmigrations
    startapp  # 创建业务应用，游戏/音乐/
    startproject # 现在创建项目也可以使用
    test
    testserver

[sessions]
    clearsessions

[staticfiles]
    collectstatic
    findstatic
    runserver # 启动服务

```

1. runserver, django不是server, django为了开发方便, 内置server. 生产使用uwsgi/gunicorn这些WSGI Server。



### 创建应用

创建员工业务employee, 脚手架生成模板应用

```
(venv) C:\Users\21923\pycharm_projects\djangot39>python manage.py startapp employee
```

![image-20220405095343749](http://myapp.image.qiniu.mykernel.cn/2022/04/05/20220405095346.png)

### 应用加入项目管理

settings 中注册应用, 才可以生成数据库配置，url映射, 后台管理

```diff
INSTALLED_APPS = [
    'django.contrib.admin',
    'django.contrib.auth',
    'django.contrib.contenttypes',
    'django.contrib.sessions',
    'django.contrib.messages',
    'django.contrib.staticfiles',
+    'employee',
]
```

1. 模块名小写
2. 类才大写

## 本地化

settings 中, 汉化, 内建的页面默认英文，现在修改成中文

```diff
# Internationalization
# https://docs.djangoproject.com/en/3.2/topics/i18n/

+#LANGUAGE_CODE = 'en-us'
+LANGUAGE_CODE = 'zh-Hans'
```

## 时区

settings 中, 默认是格林威治时间, 等价0时区。

```diff
+# TIME_ZONE = 'UTC'
+TIME_ZONE = 'Asia/Shanghai'
```

## 日志

[Common Web application tools](https://docs.djangoproject.com/en/3.2/) -> [logging](https://docs.djangoproject.com/en/3.2/topics/logging/)

抄代码, settings 中 最后一行

```diff
import os

LOGGING = {
    'version': 1,
    'disable_existing_loggers': False,
+    'handlers': { # 可以添加写文件
+        'console': { # 控制台
            'class': 'logging.StreamHandler',
        },
    },
    'root': { # root默认WARNING
+        'handlers': ['console'], # 控制台
        'level': 'WARNING',
    },
    'loggers': {
+        'django.db.backends': { # 关心django
+            'handlers': ['console'], # console表示Stream
+            'level': 'DEBUG', # sql语句
+            'propagate': False, # 是否向父级传播。自己有handdler, 不向root传播。我自己是django.
        },
    },
}
```

1. console 表示 stream
2. root 是rootlogger
3. loggers中，默认django, 但是有级别。有django.request, django, django.db.backend.
4. 需要看SQL, 需要DEBUG=True, 同时django.db.backends 是DEBUG

## 启动

```python
(venv) C:\Users\21923\pycharm_projects\djangot39>python manage.py runserver
Watching for file changes with StatReloader
Performing system checks...

Waiting for apps ready_event.
Apps ready_event triggered. Sending autoreload_started signal.
Watching dir C:\Users\21923\pycharm_projects\djangot39\locale with glob **/*.mo.
Watching dir C:\Users\21923\pycharm_projects\djangot39\employee\locale with glob **/*.mo.
System check identified no issues (0 silenced).
(0.000)
                SELECT VERSION(),
                       @@sql_mode,
                       @@default_storage_engine,
                       @@sql_auto_is_null,
                       @@lower_case_table_names,
                       CONVERT_TZ('2001-01-01 01:00:00', 'UTC', 'UTC') IS NOT NULL
            ; args=None
(0.000) SET SESSION TRANSACTION ISOLATION LEVEL READ COMMITTED; args=None
(0.000) SHOW FULL TABLES; args=None

You have 18 unapplied migration(s). Your project may not work properly until you apply the migrations for app(s): admin, auth, contenttypes, sessions. # 需要将认证，session迁移到数据库
Run 'python manage.py migrate' to apply them. # 运行迁移
April 05, 2022 - 10:17:42
Django version 3.2, using settings 'salary.settings'
Starting development server at http://127.0.0.1:8000/
Quit the server with CTRL-BREAK.
```

![image-20220405101851158](http://myapp.image.qiniu.mykernel.cn/2022/04/05/20220405101852.png)

## 迁移django系统表

django代码 -> 迁移 -> db

- [x] 制作迁移文件

  - [x] django内置表，默认就有迁移文件。
  - [x] 自己写的model类，需要迁移。

  ```
  python manage.py makemigrations
  ```

- [x] 迁移，建表

  ```
  python manage.py migrate
  ```

```bash
(venv) C:\Users\21923\pycharm_projects\djangot39>python manage.py
    makemigrations # 生成SQL语句
    migrate        # 建表
```



生成SQL语句

```bash
(venv) C:\Users\21923\pycharm_projects\djangot39>python manage.py makemigrations
(0.000) # 数据库语句
                SELECT VERSION(),
                       @@sql_mode,
                       @@default_storage_engine,
                       @@sql_auto_is_null,
                       @@lower_case_table_names,
                       CONVERT_TZ('2001-01-01 01:00:00', 'UTC', 'UTC') IS NOT NULL
            ; args=None
(0.000) SET SESSION TRANSACTION ISOLATION LEVEL READ COMMITTED; args=None
(0.000) SHOW FULL TABLES; args=None
No changes detected # 无变化
```

应用SQL

```bash
(venv) C:\Users\21923\pycharm_projects\djangot39>python manage.py migrate
(0.016) INSERT INTO `django_migrations` (`app`, `name`, `applied`) VALUES ('auth', '0010_alter_group_name_max_length', '2022-04-05 02:23:23.468065'); args=['auth', '0010_alter_group_name_max_length', '2022-04-05 02:23:23.468065'] # 在migrate就是执行SQL脚本
```

![image-20220628100947805](http://qiniu.mykernel.cn/typora/image-20220628100947805.png)

| 表名              | 描述       |
| ----------------- | ---------- |
| django_migrations | 迁移记录表 |




【devops】02 django基础概念

# wsgi

wsgi：web server gateway interface

## CS开发

CS: ip主机间路由, port进入主机后找进程。

- client: 主动请求
- server: 响应请求

## BS开发

发明www之后

BS：: ip主机间路由, port进入主机后找进程。

- Browser(渲染引擎,JS引擎): 主动请求, <b style="color: red;">发基于tcp的http请求(文本), 对http响应解析,渲染成网页;</b> http://www.mykernel.cn:80/index.html
  - www.mykerne.cn 解析为ip, 主机间路由
  - 目标主机，到达 监听80端口的进程
  - 进程处理, /index.html对应磁盘上的文件，打开，读，发给用户
- www server: 响应请求, html, 磁盘上的文件。open, read 'br' 二进制读取, send
  - 解析http请求, 理解URL
  - 解析出请求URL中的PATH, 映射（路由）, 找到资源内容
  - 包装成http响应报文返回



 

## 网页技术

> **WSGI Server**(httpd内嵌wsgi 或 uwsgi 或 gunicron),  一个动态页面，必须遵守WSGI协议规范处理。静态页面，磁盘加载响应。 app不是server,是函数，所以wsgi server和app一定在同一个服务器。
>
> - WSGI协议规定:
>
>   - 接收请求
>   - 来的请求 request 转换为 environ，字典。 
>   - 之后调用app(environ, start_response), start_response 处理响应状态码和首部。
>   - app返回前, app内部必须调用start_response处理响应状态码和首部
>   - app返回值是响应正文，没有响应状态和首部。
>
>   > app是遵循wsgi协议的，python实现有flask, django, tornado.

![01-uwsgi](http://myapp.image.qiniu.mykernel.cn/2022/03/30/20220330225837.png)

### app 实现

django/flask实现

```
def app(x,y): # 定义的形参
	# 省略10万行: path映射
	y(status, [('key', 'value')]) # 调用实参, 处理响应
	return ['abc', 'xyz']; # 返回可迭代对象
```

1. app(x,y) 即是 app(environ,start_response)
2. app返回前 start_response(status,[('key', 'value')])
3. 返回可迭代对象

### 后期nginx

后期nginx动静分离

静态不由wsgi server处理, nginx, sendfile优化。

动态，qps抗不住。动少，静多。动多了mysql抗不住



## wsgi服务器 -- wsgiref

python 3.8有新的语法; python 3.6/3.7比较成熟的版本;

> 准备python3.8项目

### wsgi基于socket server 原理实现过程

![image-20220401155218001](http://myapp.image.qiniu.mykernel.cn/2022/04/01/20220401155226.png)

```python
print(f'加载到 {__name__}')


from socketserver import ThreadingTCPServer
from socketserver import StreamRequestHandler


def app(e,s): #environ, start_response Django
    # 省略10万行
    s('200 OK',[('Content-Type', 'text/html; charset=utf-8')]) # start_response
    return [b'abc',b'xyz']


def start_response(): # 难
	# 制作headers
    pass

class WsgiHandler(StreamRequestHandler): # setup/handler/finish
    def handle(self):
        # self.request socket , self.server, self.client_address
        # self.request.makefile => wfile wb  rfile rb
        data = self.request.recv(1024) # 请求报文
        # data => {}  
        environ = parse(data) # 请求报文 封装成字典。难
        
        ret = app(environ, start_response) # 实参, 调用app，返回响应体

        # server中要把头和身体拼接并返回响应报文格式

        firstline = '200 OK HTTP/1.1' # start_response() 完成
        headers   = "'Content-Type': 'text/html; charset=utf-8'" # start_response() 完成
        header = (firstline + '\r\n' + headers + '\r\n\r\n').encode() # start_response() 完成
        body = b"".join(ret).decode()
        
        
        self.request.send(header + body) # 响应
       



server = ThreadingTCPServer( ('127.0.0.1', 8080), WsgiHandler)

print(f'加载结束=== {__name__}')
```

有难度：

- parse, 解析request
- start_response, 发header

所以使用以下的方法，只需要app(environ, start_response)函数定义

### wsgi 简单实现过程

```
print(f'加载到 {__name__}')


# ref 参考，不能用于生产环境
from wsgiref.simple_server import make_server, demo_app


# 把dmeo_app拷贝过来
def demo_app(environ,start_response):
    from io import StringIO
    stdout = StringIO()
    print("Hello world!", file=stdout)
    print(file=stdout)
    h = sorted(environ.items())
    for k,v in h:
        print(k,'=',repr(v), file=stdout)
    start_response("200 OK", [('Content-Type','text/plain; charset=utf-8')])
    return [stdout.getvalue().encode("utf-8")]


server = make_server('127.0.0.1',8080, demo_app)



print(f'加载结束=== {__name__}')
```

简化

```
print(f'加载到 {__name__}')


# ref 参考，不能用于生产环境
from wsgiref.simple_server import make_server, demo_app


# 把dmeo_app拷贝过来
def demo_app(environ,start_response):

    start_response("200 OK", [('Content-Type','text/plain; charset=utf-8')])
    return [b'abc',b'xyz']


server = make_server('127.0.0.1',8080, demo_app)

server.serve_forever()

print(f'加载结束=== {__name__}')
```

![image-20220401162426522](http://myapp.image.qiniu.mykernel.cn/2022/04/01/20220401162431.png) 

> 除了标头的首行和content-type, 都是WSGI Server的start_reponse完成。
>
> wsgi server实现有: uwsgi, gunicorn. 只需要告诉他app(django flask), <b style="color: red;">我们只管app, 传递environ</b>, environ就是wsgi解析的请求报文。
>
> 内部原理看前面, nginx+wsgi

```
print(f'加载到 {__name__}')


# ref 参考，不能用于生产环境
from wsgiref.simple_server import make_server, demo_app


html ="""
<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>test page</title>
</head>
<body>
    <h2 style="color: red;">welcome to magedu -- {}</h2>
</body>
</html>
""".format(8888).encode()


def fn():
    with open('1.html','r',encoding='utf-8') as fb:
        data =  fb.read() # {}
        x = 123 # 来自数据库
        # return data.format(x).encode() # 基于文件动态生成
        return html # 直接动态生成

# 把dmeo_app拷贝过来
def demo_app(environ,start_response):
    content = fn()
    
    
    start_response("200 OK", [('Content-Type','text/html; charset=utf-8')]) # 发header
    return [content] # 返回内容


server = make_server('127.0.0.1',8080, demo_app)

server.serve_forever()

print(f'加载结束=== {__name__}')
```


【devops】01-网页技术原理

# pod

## 启动

根据启动时间降序（descending order）

```bash
kubectl get pods --sort-by=.metadata.creationTimestamp
```

根据启动时间升序（ascending order）

```bash
kubectl get pods --sort-by=.metadata.creationTimestamp | awk 'NR == 1; NR > 1 {print $0 | "tac"}'
kubectl get pods --sort-by=.metadata.creationTimestamp | tail -n +2 | tac
kubectl get pods --sort-by={metadata.creationTimestamp} --no-headers | tac
kubectl get pods --sort-by=.metadata.creationTimestamp | tail -n +2 | tail -r
```

根据pods的重启次数进行排序

```bash
kubectl get pods -A --sort-by='.status.containerStatuses[0].restartCount'
```




## 清理

清理K8s异常pod

```bash
#clean Evicted
kubectl get pods --all-namespaces -o wide | grep Evicted | awk '{print $1,$2}' | xargs -L1 kubectl delete pod -n 
# clean error
kubectl get pods --all-namespaces -o wide | grep Error | awk '{print $1,$2}' | xargs -L1 kubectl delete pod -n 
#clean compete
kubectl get pods --all-namespaces -o wide | grep Completed | awk '{print $1,$2}' | xargs -L1 kubectl delete pod -n 
```

强制删除指定namespace下`Terminating`状态的pod【使用之前请验证】

```bash
kubectl get pod -n $namespace |grep Terminating|awk '{print $1}'|xargs kubectl delete pod --grace-period=0 --force
```

批量强制删除集群内`Terminating`状态的pod【使用之前请验证】

```bash
for ns in $(kubectl get ns --no-headers | cut -d ' ' -f1); do \
  for po in $(kubectl -n $ns get po --no-headers --ignore-not-found | grep Terminating | cut -d ' ' -f1); do \
    kubectl -n $ns delete po $po --force --grace-period 0; \
  done; \
done;
```

获取`CrashLoopBackOff`的pod

```bash
kubectl get pod -A |grep CrashLoopBackOff

CrashloopBackOff 表示pod经历了 starting , crashing 然后再次 starting 并再次 crashing 。

这个失败的容器会被kubelet不断重启，并且按照几何级数(exponentially)延迟(10s,20s,40s…)直到5分钟，最后一次是10分钟后重置。默认使用的是 podRestartPolicy

PodSpec 有一个 restartPolicy 字段，值可以是 Always , OnFailure 和 Never ，默认是 Always

导致 CrashLoopBackOff 的原因通常有:
1. 容器中应用程序持续crash
2. pod/container的参数配置错误
3. 当部署Kubernetes pod是出现错误
```

临时释放的指定namespace下的pod

```bash
适用于不想删除 Kubernetes 集群內的信息

# 方法一：通过 patch 模式
kubectl get deploy -o name -n <NAMESPACE>|xargs -I{} kubectl patch {} -p '{"spec":{"replicas":0}}'

# 方法二：通过资源伸缩副本数
kubectl get deploy -o name |xargs -I{} kubectl scale --replicas=0 {}

```
## 清理卷

清理没有使用的 pv

```bash
kubectl describe -A pvc | grep -E "^Name:.*$|^Namespace:.*$|^Used By:.*$" | grep -B 2 "<none>" | grep -E "^Name:.*$|^Namespace:.*$" | cut -f2 -d: | paste -d " " - - | xargs -n2 bash -c 'kubectl -n ${1} delete pvc ${0}'
```

清理没有被绑定的 PVC

```bash
kubectl get pvc --all-namespaces | tail -n +2 | grep -v Bound | awk '{print $1,$2}' | xargs -L1 kubectl delete pvc -n
# 
kubectl get pv | tail -n +2 | grep -v Bound | awk '{print $1}' | xargs -L1 kubectl delete pv
```

## 查找非 running 状态的 Pod

```
kubectl get pods -A --field-selector=status.phase!=Running | grep -v Complete
```
## pod端口映射

1. 将 localhost:3000 的请求转发到 nginx-pod Pod 的 80 端口

```bash
kubectl port-forward nginx-po 3000:80
```

1. 将 localhost:3201 的请求转发到 nginx-web service 的 3201 端口

```bash
kubectl port-forward svc/nginx-web 3201
```
## QoS

查看集群內 Pod 的服务质量等级（QoS）

```bash
## 查看所有pod的QoS
kubectl get pods --all-namespaces -o custom-columns=NAME:.metadata.name,NAMESPACE:.metadata.namespace,QOS-CLASS:.status.qosClass
```

### 什么是服务质量等级（QoS）

Guaranteed：Pod 里的每个容器都必须有内存/CPU 限制和请求，而且值必须相等。
Burstable：Pod 里至少有一个容器有内存或者 CPU 请求且不满足 Guarantee 等级的要求，即内存/CPU 的值设置的不同。
BestEffort：容器必须没有任何内存或者 CPU 的限制或请求。

**QoS存在的意义：**
当节点上内存资源紧张时，kubernetes 会根据预先设置的不同 QoS 类别进行相应处理。
QoS 主要分为Guaranteed、Burstable 和 BestEffort三类，优先级从高到低。
换言之，就是k8s如果资源不足，会优先干掉QoS等级低的pod。

### Guaranteed

QoS 类为 Guaranteed 的 Pod必须满足以下几点：
1. Pod 中的每个容器都必须指定内存限制和内存请求。
2. 对于 Pod 中的每个容器，内存限制必须等于内存请求。
3. Pod 中的每个容器都必须指定 CPU 限制和 CPU 请求。
4. 对于 Pod 中的每个容器，CPU 限制必须等于 CPU 请求。

### Burstable
如果满足下面条件，将会指定 Pod 的 QoS 类为 Burstable：
Pod 不符合 Guaranteed QoS 类的标准。
Pod 中至少一个容器具有内存或 CPU 的请求或限制。

### BestEffort
对于 QoS 类为 BestEffort 的 Pod，Pod 中的容器必须没有设置内存和 CPU 限制或请求。

## 调试coredns

```bash
kubectl run -it --rm --restart=Never --image=infoblox/dnstools:latest dnstools
```
## 查看容器名

```bash
kubectl get po calibre-web-76b9bf4d8b-2kc5j -o json | jq -j ".spec.containers[].name"
```
## 临时关闭 Daemonsets

如果需要临时将 Daemonsets 关闭，只需要将其调度到一个不存在的 node 上即可，调整下 nodeSelector

```bash
kubectl patch daemonsets nginx-ingress-controller -p '{"spec":{"template":{"spec":{"nodeSelector":{"project/xdp":"none"}}}}}'
```

## 创建临时可调式Pod

```bash
kubectl run ephemeral-busybox \
  --rm \
  --stdin \
  --tty \
  --restart=Never \
  --image=lqshow/busybox-curl:1.28 \
  -- sh
```
## 使用交互 shell 访问匹配到标签的 Pod

```bash
# 案例1
kubectl exec -i -t $(kubectl get pod -l <KEY>=<VALUE> -o name |sed 's/pods\///') -- bash

# 案例2
kubectl exec -i -t $(kubectl get pod -l <KEY>=<VALUE> -o jsonpath='{.items[0].metadata.name}') -- bash
```
## 在多个pod中运行命令

```bash
kubectl get pods -o name | xargs -I{} kubectl exec {} -- <command goes here>
```



# k8s

## 资源
查看node资源使用情况

```bash
kubectl get nodes --no-headers | awk '{print $1}' | xargs -I {} sh -c "echo {} ; kubectl describe node {} | grep Allocated -A 5 | grep -ve Event -ve Allocated -ve percent -ve --;"
```

查看node资源总情况

```bash
kubectl get no -o=custom-columns="NODE:.metadata.name,ALLOCATABLE CPU:.status.allocatable.cpu,ALLOCATABLE MEMORY:.status.allocatable.memory"
```
查看node cpu分配情况

```bash
kubectl get nodes --no-headers | awk '{print $1}' | xargs -I {} sh -c 'echo -n "{}\t"|tr "\n" " " ; kubectl describe node {} | grep Allocated -A 5 | grep -ve Event -ve Allocated -ve percent -ve -- | grep cpu | awk '\''{print $2$3}'\'';'
```

查看node内存分配

```bash
kubectl get nodes --no-headers | awk '{print $1}' | xargs -I {} sh -c 'echo "{}\t"|tr "\n" " " ; kubectl describe node {} | grep Allocated -A 5 | grep -ve Event -ve Allocated -ve percent -ve -- | grep memory | awk '\''{print $2$3}'\'';'
```

查看所有镜像

```bash
kubectl get pods -o custom-columns='NAME:metadata.name,IMAGES:spec.containers[*].image'
```
获取节点列表及其内存容量

```bash
kubectl get no -o json | jq -r '.items | sort_by(.status.capacity.memory)[]|[.metadata.name,.status.capacity.memory]| @tsv'
```

获取每个节点的Pod数量

```bash
kubectl get po -o json --all-namespaces | jq '.items | group_by(.spec.nodeName) | map({"nodeName": .[0].spec.nodeName, "count": length}) | sort_by(.count)'
```

## 重置集群节点【慎用】

1. 将节点标记为不可调度，确保新的容器不会调度到该节点

```bash
kubectl cordon <NODE-NAME>
```

1. Master 节点上将需要重置的节点驱逐, 除了 deemonset

```bash
kubectl drain <NODE-NAME> --delete-local-data --force --ignore-daemonsets
```

1. 删除节点

```bash
kubectl delete node <NODE-NAME>
```

1. 在需要重置节点上执⾏重置脚本，注意，如果在 Master 主节点执⾏ kubeadm reset，则需要重新初始化集群

```bash
kubeadm reset
```


# docker
## 根据overlay2目录名找容器

```bash
docker ps -q | xargs docker inspect --format '{{.Name}}, {{.State.Pid}}, {{.Id}}, {{.GraphDriver.Data.WorkDir}}'
```

## 通过变量组合展示容器绑定端口列表

```bash
docker inspect --format '{{/*通过变量组合展示容器绑定端口列表*/}}已绑定端口列表：{{println}}{{range $p,$conf := .NetworkSettings.Ports}}{{$p}} -> {{(index $conf 0).HostPort}}{{println}}{{end}}' Web_web_1
```

## 查询指定网络下的容器名称，如果存在输出容器名称，如果没有，输出With No Containers

```bash
docker inspect --format '{{range .Containers}}{{.Name}}{{println}}{{else}}With No Containers{{end}}' bridge
```

## 通过索引序号读取默认网关

```bash
docker inspect bridge --format '{{/*查看网络的默认网关*/}}{{(index .IPAM.Config 0).Gateway}}'
```

## 查看容器是否配置了容器策略

```bash
docker ps -q | xargs docker inspect --format '{{if not .State.Restarting}}{{.Name}}容器没有配置重启策略{{end}}'
```

## 查看容器当前的运行状态

```bash
docker inspect --format '{{or .State.Status .State.Restarting}}' configuration-center
```

## 显示所有容器的IP

```bash
docker inspect --format='{{range .NetworkSettings.Networks}}{{.IPAddress}}{{end}}' $(docker ps -q)
```

## 显示所有容器的mac地址

```bash
docker inspect --format='{{range .NetworkSettings.Networks}}{{.MacAddress}}{{end}}' $(docker ps -a -q)
```

## 显示所有容器的名称，并分离出反斜杠

```bash
docker inspect --format='{{.Name}}' $(docker ps -aq)|cut -d"/" -f2
```

## 获取容器的日志路径

```bash
docker inspect --format='{{.LogPath}}' docker-test1
```

# 其他

## 导出干净的YAML(kubectl-neat)

安装：

```bash
wget https://github.com/itaysk/kubectl-neat/releases/download/v2.0.3/kubectl-neat_linux_amd64.tar.gz
tar -xvf kubectl-neat_linux_amd64.tar.gz 
chmod +x kubectl-neat
cp kubectl-neat /usr/sbin/

#mac 找对应的版本即可
#或者使用kubectl插件管理工具进行安装`kubectl krew install neat`
```

用法示例：

```bash
kubectl get pod mypod -o yaml | kubectl neat
kubectl get pod mypod -oyaml | kubectl neat -o json
kubectl neat -f - <./my-pod.json
kubectl neat -f ./my-pod.json
kubectl neat -f ./my-pod.json --output yaml
```

## 复制资源到其他namespace下

复制某个namespace下的资源配置到其他namespace

比如：复制Secret到其他namespace

方案1:

```bash
# 可以用来复制镜像认证（aliregistry）或者ssl证书的secrets

kubectl get secrets aliregistry -o yaml --namespace default | \
	kubectl neat -o json| \
  jq '.metadata.namespace = "test"'| \
  kubectl create -f  -
  
```

方案2:

```bash
kubectl get secret <SECRET-NAME> -n <SOURCE-NAMESPACE> -oyaml | sed "/namespace:/d" | kubectl apply --namespace=<TARGET-NAMESPACE> -f -
```

## 获取K8s的token

```bash
kubectl -n kube-system describe $(kubectl -n kube-system get secret -n kube-system -o name | grep namespace) | grep token
```


## 容器线程数统计

```bash
printf "    ThreadNUM  PID\t\tCOMMAND\n" && ps -eLf | awk '{$1=null;$3=null;$4=null;$5=null;$6=null;$7=null;$8=null;$9=null;print}' | sort |uniq -c |sort -rn | head -10
```
## 设置deploy的环境变量

```bash
kubectl set env deploy <DEPLOYMENT_NAME> OC_XXX_HOST=bbb
```

## 配置默认storageclass

```bash
kubectl patch storageclass <your-class-name> -p '{"metadata": {"annotations":{"storageclass.kubernetes.io/is-default-class":"true"}}}'
```


## 进入容器namespace

```bash
docker ps | grep APP_NAME
docker inspect CONTAINER_ID | grep Pid
nsenter -t PID -n
```

后台管理

django orm

wsgi与app通信

wsgi

pod

启动