docker基础
目录
docker介绍
什么是虚拟化？
在计算机中，虚拟化（英语：Virtualization）是一种资源管理技术，是将计算机的各种实体资源，如服务器、网络、内存及存储等，予以抽象、转换后呈现出来，打破实体结构间的不可切割的障碍，使用户可以比原本的组态更好的方式来应用这些资源。这些资源的新虚拟部份是不受现有资源的架设方式，地域或物理组态所限制。一般所指的虚拟化资源包括计算能力和资料存储。
在实际的生产环境中，虚拟化技术主要用来解决高性能的物理硬件产能过剩和老的旧的硬件产能过低的重组重用，透明化底层物理硬件，从而最大化的利用物理硬件 对资源充分利用
虚拟化技术种类很多，例如：软件虚拟化、硬件虚拟化、内存虚拟化、网络虚拟化(vip)、桌面虚拟化、服务虚拟化、虚拟机等等。
# kvm：开源的免费的 Kernel-based Virtual Machine的简称，是一个开源的系统虚拟化模块，自Linux 2.6.20之后集成在Linux的各个主要发行版本中
# exsi:vmware商用的，装在裸机上，可以虚拟化出很多机器
# openstack（python开发的，开源的）：电信云，华为云 openstack 管理云平台
# 阿里云（自研，阿里飞天）：云服务器，到一个网站，点点---》付款--》完成
# docker：容器技术
# k8s：多机容器管理，容器编排
docker是什么？
Docker 是一个开源项目，诞生于 2013 年初，最初是 dotCloud 公司内部的一个业余项目。它基于 Google 公司推出的 Go 语言实现。 项目后来加入了 Linux 基金会，遵从了 Apache 2.0 协议，项目代码在 [GitHub](https://github.com/docker/docker) 上进行维护
# Docker 自开源后受到广泛的关注和讨论，以至于 dotCloud 公司后来都改名为 Docker Inc。Redhat 已经在其 RHEL6.5 中集中支持 Docker；Google 也在其 PaaS 产品中广泛应用。
# Docker 项目的目标是实现【轻量级的操作系统虚拟化解决方案】。 Docker 的基础是 Linux 容器（LXC）等技术。
在 LXC 的基础上 Docker 进行了进一步的封装，让用户不需要去关心容器的管理，使得操作更为简便。用户操作 Docker 的【容器就像操作一个快速轻量级的虚拟机】一样简单。
容器与虚拟机比较
Docker概念
# 1 docker 是cs架构 ，mysql，redis，c和s要通信，使用的http协议，符合resful规范
# 2 Docker镜像：镜像是基于一堆文件，相当于虚拟机装了操作系统，又装了软件的一堆文件
# 3 Docker容器：镜像运行起来，成为了容器，【当成一台虚拟机上面装了一些软件】
- 类和对象的概念
- 镜像是类---》生成多个对象
# 4 Registry（注册中心）
-镜像从哪里来？
-注册中心中拉取下来
docker安装
（1）yum 包更新到最新
yum remove docker docker-common docker-selinux docker-engine
rm -rf /var/lib/docker
sudo yum update
（2）安装需要的软件包， yum-util 提供yum-config-manager功能，另外两个是devicemapper驱动依赖的
sudo yum install -y yum-utils device-mapper-persistent-data lvm2
（3）设置yum源为阿里云
sudo yum-config-manager --add-repo http://mirrors.aliyun.com/docker-ce/linux/centos/docker-ce.repo
（4）安装docker
sudo yum install docker-ce
（5）安装后查看docker版本
docker -v
什么是laas-Paas和Saas
Iaas: Infrastructure-as-a-Service（基础设施即服务）
IaaS公司会提供场外服务器，存储和网络硬件，你可以租用。节省了维护成本和办公场地，公司可以在任何时候利用这些硬件来运行其应用
Paas:平台即服务
paaS公司在网上提供各种开发和分发应用的解决方案，比如虚拟服务器和操作系统。这节省了你在硬件上的费用，也让分散的工作室之间的合作变得更加容易。网页应用管理，应用设计，应用虚拟主机，存储，安全以及应用开发协作工具等
Saas:软件即服务
-软件开发，部署，运维---》公司来做，卖给其他公司软件
FAAS：Function as a Service，"功能即服务"（也译作“函数即服务”）
无服务器架构 serverless
docker 启动设置镜像
# 查看docker状态:
systemctl status docker
# 启动docker:
systemctl start docker
# 远程仓库，下载镜像 ，国外：https://hub.docker.com---》下载比较慢--》设置国内镜像站
-https://cr.console.aliyun.com/cn-shanghai/instances/mirrors
# docker安装后会有 /etc/docker 文件夹
切换到
cd /etc/docker
编辑:
vim /etc/docker/daemon.json
{
"registry-mirrors": ["https://r1m0m81l.mirror.aliyuncs.com"]
}
重启docker:
sudo systemctl daemon-reload
sudo systemctl restart docker
启动与常用命令
# 启动docker：
systemctl start docker
# 停止docker：
systemctl stop docker
# 重启docker：
systemctl restart docker
# 查看docker状态：
systemctl status docker
# 开机启动：
systemctl enable docker
# 查看docker概要信息
docker info
# 查看docker帮助文档
docker --help
镜像相关命令
# 1 查找镜像
-docker search 镜像名称
-建议去hub.docker.com 直接搜，更直观
# 2 拉取镜像，指定标签 tag
docker pull centos:7
如果不指定标签，会下载最新
docker pull centos
docker pull centos:latest
# 3 查看本地镜像
docker images # 等同于 docker image ls
# 4 删除镜像
docker rmi 镜像ID # 可以同时删多个
# 5 删除所有镜像
# 查出所有镜像的id号
docker rmi `docker images -q`
容器相关命令
# 把镜像运行成容器，并且一个一个镜像，可以运行出多个容器
# 查看正在运行的容器
docker ps
# 查看所有容器
docker ps -a
# 查看最后一次运行的容器
docker ps -l
# 运行容器（其实是两步：创建容器:create，运行容器:run）
-如果容器没有创建，直接执行run，就会创建并运行，所以你只需要会run就行了
-run 的时候，有很多参数
-i：表示运行容器
-t：表示容器启动后会进入容器命令行。加入这两个参数后，容器创建就能登录进去。即分配一个伪终端。
-d：在run后面加上-d参数,则会创建一个守护式容器在后台运行（这样创建容器后不会自动登录容器，如果只加-i -t两个参数，创建后就会自动进去容器）
--name :为创建的容器命名，如果不写，随机生成一个名字
-v：表示目录映射关系（前者是宿主机目录，后者是映射到宿主机上的目录），可以使用多个－v做多个目录或文件映射。注意：最好做目录映射，在宿主机上做修改，然后共享到容器上。
-p：表示端口映射，前者是宿主机端口，后者是容器内的映射端口。可以使用多个-p做多个端口映射
docker run -id # 不会进入到容器内部
docker run -it # 会进入到容器内部
# 启动一个centos容器,名字叫mycentos，并且进入
docker run -it --name=mycentos centos:7
yum install vim -y # 在容器中装了vim软件
exit # 退出，容器停止了
# 启动一个centos容器,名字叫mycentos，不进入
docker run -id centos:7
# 启动容器
docker start mycentos
# 进入到容器内部（本质是让容器执行命令）
docker exec 容器id 命令
docker exec f82e8578b9b1 ls
docker exec -it f82e8578b9b1 /bin/bash # 进入到容器内部
# 退出
exit
# -v参数：目录映射
docker run -id --name=lqz -v /home/lqz:/lqz centos:7
以后无论在宿主机还是容器中修改当前目录下的文件，都会相互影响
# -p参数：端口映射 容器中启动一个mysql5.7 --》容器中的3306监听，宿主机3306没人监听，做端口映射后，宿主机的3306就被docker的这个容器监听了
# 启动的mysql的root密码是123456
docker run -id --name=mysql -p 80:3306 -e MYSQL_ROOT_PASSWORD=123456 mysql:5.7
# netstat -nlp |grep 80 查看本机80端口占用情况
# 以后访问宿主机80端口就等于访问容器的3306端口
容器操作
启动容器
docker start 容器id
停止容器
docker stop 容器id
文件拷贝
# 容器的文件copy到宿主机上(不是在容器内执行)
docker cp 容器名称:容器目录 需要拷贝的文件或目录
docker cp 20fd8:/home/lqz.txt /home/lqz.txt
# 宿主机的文件copy到容器中
docker cp 需要拷贝的文件或目录 容器名称:容器目录
docker cp ./lqz.txt 20fd894a3f20:/home/lqz.txt
查看容器IP地址
docker inspect 容器名称 # 查看容器的详细描述,很多
docker inspect --format='{{.NetworkSettings.IPAddress}}' 容器名称（容器ID）
# 在多个容器之间是可以ping通的
# centos:172.17.0.3
# mysql:172.17.0.2
# 删除容器（删除已停止的容器）
docker rm 容器id
docker rm `docker ps -a -q`
# 无状态的服务
-myslq reids
-uwsgi+django
应用部署
mysql部署
# 简单的启动一个mysql容器
docker run -di --name=mysql -p 3306:3306 -e MYSQL_ROOT_PASSWORD=123456 mysql:5.7
# 做目录映射：data文件，配置文件
# 创建文件夹
mkdir /home/mysql
mkdir /home/mysql/conf.d
mkdir /home/mysql/data/
# 编辑文件内容,修改mysql配置映射到容器中
vim /home/mysql/my.cnf
# 配置文件写法
[client]
default-character-set=utf8
[mysqld]
user=mysql
character-set-server=utf8
default_authentication_plugin=mysql_native_password
secure_file_priv=/var/lib/mysql
expire_logs_days=7
sql_mode=STRICT_TRANS_TABLES,NO_ZERO_IN_DATE,NO_ZERO_DATE,ERROR_FOR_DIVISION_BY_ZERO,NO_ENGINE_SUBSTITUTION
max_connections=1000
# 启动镜像带有目录映射,端口映射
docker run -di -v /home/mysql/data/:/var/lib/mysql -v /home/mysql/conf.d:/etc/mysql/conf.d -v /home/mysql/my.cnf:/etc/mysql/my.cnf -p 3306:3306 --name mysql -e MYSQL_ROOT_PASSWORD=123456 mysql:5.7
# 创建库，创建表，插入数据
# 关闭容器，删除容器，myslq的容器没了，但是数据在宿主机上放着
# 再运行起一个容器，做好目录映射，数据都回来了
redis
# 拉取redis镜像
docker pull redis
mkdir /root/data
vim /root/redis.conf
bind 0.0.0.0
daemonize NO
protected-mode no
requirepass 123456
# 运行
docker run -id -p 6379:6379 --name redis -v /root/redis.conf:/etc/redis/redis.conf -v /root/data:/data redis redis-server /etc/redis/redis.conf
# 远程链接redis操作
nginx
# 拉取nginx镜像
docker pull nginx
# run起容器
# docker run -id --name nginx -p 80:80 nginx
# /usr/share/nginx/html
docker run -id --name nginx -p 80:80 -v /root/html:/usr/share/nginx/html nginx
# 以后只需要修改宿主机的/root/html 路径，看到页面就是修改后的
迁移与备份
# 容器保存为镜像
-运行一个centos容器
docker run -id --name centos_vim centos:7
-在容器中装vim
docker exec -it a6e240 /bin/bash
yum install vim -y
-把容器做成镜像（centos+vim）
docker commit centos_vim centos_vim_image
-把centos_vim 容器删除
docker rm centos_vim
-基于新构建的镜像，运行成容器
docker run -id --name centos_vim centos_vim_image:latest
-进入到容器中，查看，软件都在
docker exec -it id号 /bin/bash
# 镜像备份和恢复
docker save -o centos_vim_image.tar centos_vim_image
-删除容器，删除镜像
-把备份的镜像恢复
docker load -i centos_vim_image.tar
Dockerfile
镜像从哪里来的?
1.远程仓库拉取的 docker pull
2.把容器做成的镜像 docker commit
3.把备份的回复 docker load
4.使用Dockerfile来构建
什么是Dcokerfile?
Dockerfile是由一系列命令和参数构成的脚本文件,这些命令应用于基础镜像并最终创建一个新的镜像
Dcokerfile命令
FROM 基础镜像 #基于哪个基础镜像来构建
MAINTAINER lqz # 声明镜像的创建者
ENV key value # 设置环境变量 (可以写多条)
RUN command #是Dockerfile的核心部分(可以写多条)
ADD source_dir/file dest_dir/file #将宿主机的文件复制到容器内，如果是一个压缩文件，将会在复制后自动解压
COPY source_dir/file dest_dir/file # 和ADD相似，但是如果有压缩文件并不能解压
WORKDIR lqz # 设置工作目录，运行起这个容器，来到的路径就是这个路径
# 构建一个带vim的centos镜像
vim Dockerfile
FROM centos:7
MAINTAINER lqz
ENV name lqz
RUN yum install vim -y
RUN mkdir /lqz
RUN touch /lqz/ss.py
RUN echo 'print(1)' >/lqz/ss.py
COPY /root/redis.conf /lqz/redis.conf
WORKDIR /lqz
# 基于dockerfile构建镜像
docker build -t='centos_lqz_vim' .
# 基于这个镜像运行容器
docker run -id --name xx centos_lqz_vim
# 进入到容器
docker exec -it xx /bin/bash
# 验证vim，和文件夹，文件是否存在
Dockerfile
常用和不常用命令
FROM：指定基础镜像
RUN：构建镜像过程中需要执行的命令,可以多条,docker build
CMD：添加启动容器时需要执行的命令,多条只有最后一条生效,可以在启动容器时被覆盖和修改
ENTRYPOINT：同CMD，但这个一定会被执行，不会被覆盖修改。
MLABELAINTAINER：表明镜像的作者。将被遗弃，被LABEL代替。
EXPOST:设置对外暴露的接口
ENV：设置执行命令时的环境变量,并且在构建完成后,仍然生效
ARG：设置只在构建过程中使用的环境变量,构建完成后,将消失
ADD：将本地文件或目录拷贝到镜像的文件系统中,能解压特定格式文件,能将URL作为要拷贝的文件
COPY：将本地文件或目录拷贝到镜像的文件系统中
WORKDIR：设置工作目录
ONBUILD：如果制作的镜像被另一个Dockerfile使用，将在那里被执行Docekrfile命令
STOPSIGNAL：设置容器退出时发出的关闭信号。
HEALTHCHECK：设置容器状态检查。
SHELL：更改执行shell命令的程序。Linux的默认shell是[“/bin/sh”, “-c”]，Windows的是[“cmd”, “/S”, “/C”]。
使用dockerfile构建一个django项目
# 公司中，使用Docker开发的工作流程
第一步：有一个项目，pycharm开发着，开发完后
第二步：在项目路径下新建Dockerfile，写入
FROM python:3.8
MAINTAINER lqz
WORKDIR /soft
COPY ./requirements.txt /soft/requirements.txt
RUN pip install -r requirements.txt -i https://pypi.doubanio.com/simple
CMD ["python","manage.py","runserver","0.0.0.0:8080"]
第三步：把代码提交到git
------------------
第四步：上线人员：在上线机器上，把代码啦下来
git clone https://gitee.com/liuqingzheng/books.git
第五步：构建镜像
docker build -t='django_books' .
第六步：运行容器
docker run -id --name=books -v /root/lqz/books:/soft -p 8080:8080 django_books:latest
第七步：其它人访问宿主机的8080端口就能看到项目了
---------
第八步：开发人员继续提交代码
第九步：运维人员pull代码，重启容器，用户就可以看到最新的了
重启docker容器即可(第三方依赖变了)--》重写构建镜像，运行容器
docker私有仓库
# 有个远程仓库 ，docker官方提供的 ---》我们可以把我们的镜像传上去
# 公司做的镜像，一般不放在远程仓库，公司会自己搭建私有仓库（把公司制作的镜像传到私有仓库）
镜像传到官方仓库
# 第0步：在远端创建仓库
# 第一步：给镜像打标签
docker tag ab5c0e652fd4 liuqingzheng/centos_vim:v1
# 第二步：登录到远程
docker login
用户名：不是邮箱
密码：挺复杂
# 第三步：提交
docker push liuqingzheng/centos_vim:v1
# 第四步：别人就可以下载了
docker pull liuqingzheng/centos_vim:v1
镜像分层
每一个Dockerfile命令都会构建一层镜像(本质上是每一层都会启动一个容器,执行完命令后，将容器进行提交通过查看下载下来的镜像,发现历史层信息的层id是missing,其实是因为原本的层id只存在于构建镜像的宿主机上,一旦转义镜像后,历史层消息中将只保留最新一层的id)
RUN yum install vim -y
RUN yum install git -y
# 查看镜像分层的命令
docker history liuqingzheng/centos_vim:v1
# 好处：
构建快，分发方便，如果本地有某一层了，这一层就不需要下载了
# 补充：Dcokerfile写命令，建议多条命令合为一条
RUN python -m pip install --upgrade pip &&\
python -m pip install --upgrade setuptools &&\
pip install -r requirements.txt
私有仓库搭建
# 自己搭建私有仓库
-harbor：企业级私有仓库---》https://blog.csdn.net/Gf19991225/article/details/121982824
- registry：用docker搭建私有仓库
# 搭建步骤：
-第一步：拉取镜像 docker pull registry
-第二步：运行容器：docker run -di --name=registry -p 5000:5000 registry
-第三步：打开浏览器 输入地址http://47.103.74.128:5000/v2/_catalog看到{"repositories":[]} 表示私有仓库搭建成功并且内容为空
-第四步：修改daemon.json
vi /etc/docker/daemon.json
{
"insecure-registries":["47.103.74.128:5000"]
}
-第五步：重启docker 让配置生效
systemctl restart docker
docker start registry
-第六步：把某个镜像tag成私有仓库的镜像
docker tag 镜像名字/id 47.103.74.128:5000/django_books:v1
-第七步：提交到私有仓库
docker push 47.103.74.128:5000/django_books:v1
-第八步：其他人，只要配置了私有仓库就可以直接拉取
docker pull 47.103.74.128:5000/django_books:v1
dockercompose介绍
使用docker面临一个比较大的问题，如果一个django项目使用mysql,redis不要一次性把所有服务都放到一个容器上,每个服务一个容器,批量的管理多个容器,比较难以操作,于是有了docker-compose
Dcoer Compose是一个能一次性定义和管理多个Docker容器的工具,单级容器编排[定义和管理]
多容易编排:
-docker swarm
-k8s
Compose中定义和启动的每一个容器都相当于一个服务(service)
Compose中能定义和启动多个服务，且它们之间通常具有协同关系
管理方式：
使用YAML文件来配置我们应用程序的服务。
使用单个命令（docker-compose up），就可以创建并启动配置文件中配置的所有服务。
# 安装docker-compose （可执行文件，放在了github上，下载下来即可，速度很慢）
# https://github.com/docker/compose/releases
wget https://github.com/docker/compose/releases/download/v2.15.1/docker-compose-linux-x86_64
cp ./docker-compose-linux-x86_64 /usr/local/bin/docker-compose
chmod +x /usr/local/bin/docker-compose
# 以后在任意位置敲docker-compose都可以
# 常用命令
# 启动管理容器
docker-compose up # 会自动搜索当前路径下的 docker-compose.yml文件
docker-compose -f 指定文件 up
docker-compose up -d # 后台执行，一般我们看日志输出，不用这个
docker-compose stop # 停止，不会删除容器和镜像
docker-compose down # 停止，并删除关联的容器
docker-compose start # 启动yml文件管理的容器
docker-compose ps # 正在运行的容器
docker-compose images # docker-compose管理的镜像
docker-compose exec yml文件中写的service /bin/bash # 进入到容器内
dockercompose部署flask+redis项目
新建flask app.py
from flask import Flask
from redis import Redis
import os
app = Flask(__name__)
redis = Redis(host=os.environ.get('REDIS_HOST', '127.0.0.1'), port=6379)
@app.route('/')
def hello():
redis.incr('hits')
return '你好! 查看 %s 次\n' % (redis.get('hits'))
if __name__ == "__main__":
app.run(host="0.0.0.0", port=5000, debug=True)
编写Dockerfile--》用于构建flask项目的镜像
FROM python:3.8
WORKDIR /app
COPY . /app
RUN pip install flask redis -i https://pypi.tuna.tsinghua.edu.cn/simple
EXPOSE 5000
CMD [ "python", "app.py" ]
编写docker-compose的yaml文件 docker-compose.yml
version: "3"
services:
redis:
image: redis
web:
build:
context: .
dockerfile: Dockerfile
ports:
- 8080:5000
environment:
REDIS_HOST: redis
docker-compose启动
# 如果redis服务的名字叫redis，我在web服务中(容器中)，根据redis名字就能拿到容器
ping redis
# 进入到了web，ping redis
# 安装ping命令，
apt-get update
apt-get install inetutils-ping
ping redis
# 一键部署：redis，和flask ，每个都在一个容器中
docker-compose up
dockercompose一键部署路飞项目
# 一台服务器：
-python3.8 环境 djagno +uwsgi+代码
-nginx软件
-mysql 5.7
-redis
# 每个都做成一个容器
-djagno项目容器：python3.8 构建的django，模块，uwsgi，代码
-nginx容器：目录映射，映射到宿主机，代理vue前端，编译后的静态文件
-mysql 容器：创建，创用户，密码，luffy库
-redis 容器，跑起来即可
# docker-compose yml文件配置，一键启动
-git clone https://gitee.com/liuqingzheng/luffy.git
-目录结构
luffy
luffy_api # 后台项目
Dockerfile
luffycity # 前台项目
docker_compose_files # 放数据的文件夹
docker-compose.yml #ymal文件
-docker-compose.yml内容
-Dockefile 文件
- 修改前端链接后台的地址：luffycity/src/access/xx.js
-编译：npm run build
-提交到git
-要部署的服务器：git clone https://gitee.com/liuqingzheng/luffy.git
-docker，docker-compose装好
-docker-compose up
-访问宿主机的 80 端口
项目目录结构
luffy
-docker_compose_files # nginx有自己的配置文件，redis自己的配置，mysql的配置
nginx # 文件夹
redis # 文件夹
mysql.env#配置文件
-luffy_api # 原来路飞后端项目
-Dockerfile
-luffy.ini # luffy.xml uwsgi的配置文件
-luffycity # 前端项目
-docker-compose.yml # docker-compose的配置文件
# 把luffycity/dist 文件夹删除
# 把\luffy\luffycity\src\assets\js\settings.js后端地址改成上线地址(服务器地址)
# 来到前端路径下：luffy\luffycity
cnpm install 安装依赖
# 编译，在\luffy\luffycity\dist文件夹
npm run build
# 提交到git上
# 在部署的机器上，git clone 下来
# 进入到项目目录
docker-compose up
luffy_api/Dockerfile--->构建uwsgi+django
FROM python:3.8
MAINTAINER lqz
WORKDIR /soft
COPY ./requestment.txt /soft/requestment.txt
RUN pip install -r requestment.txt -i https://pypi.doubanio.com/simple
#CMD ["uwsgi", "-x", "./luffy.xml"]
CMD ["uwsgi", "./luffy.ini"]
#CMD ["python", "manage_pro.py", "runserver"]
docker-compose.yml
version: "3"
services:
nginx:
image: nginx
container_name: luffy_nginx
ports:
- "80:80"
- "8000:8000"
restart: always
volumes:
- ./luffycity/dist:/var/www/html
- ./docker_compose_files/nginx:/etc/nginx/conf.d
depends_on:
- django
networks:
- web
django:
build:
context: ./luffy_api
dockerfile: Dockerfile
container_name: luffy_django
# command: python manage_pro.py makemigrations && python manage_pro.py migrate && uwsgi ./luffy.ini
restart: always
ports:
- "8080:8080"
volumes:
- ./luffy_api:/soft
environment:
- TZ=Asia/Shanghai
depends_on:
- mysql
- redis
networks:
- web
redis:
image: redis:6.0-alpine
container_name: luffy_redis
ports:
- "6379:6379"
volumes:
- ./docker_compose_files/redis/data:/data
- ./docker_compose_files/redis/redis.conf:/etc/redis/redis.conf
command: redis-server /etc/redis/redis.conf
networks:
- web
mysql:
image: mysql:5.7
container_name: luffy_mysql
restart: always
ports:
- "3306:3306"
env_file:
- ./docker_compose_files/mysql.env
volumes:
- ./docker_compose_files/mysql/data:/var/lib/mysql
- ./docker_compose_files/mysql/logs:/var/log/mysql
- ./docker_compose_files/mysql/conf:/etc/mysql/conf.d
networks:
- web
networks:
web:
一键部署
docker-compose up
【推荐】国内首个AI IDE，深度理解中文开发场景，立即下载体验Trae
【推荐】编程新体验，更懂你的AI，立即体验豆包MarsCode编程助手
【推荐】抖音旗下AI助手豆包，你的智能百科全书，全免费不限次数
【推荐】轻量又高性能的 SSH 工具 IShell：AI 加持，快人一步
· 全程不用写代码，我用AI程序员写了一个飞机大战
· MongoDB 8.0这个新功能碉堡了，比商业数据库还牛
· 记一次.NET内存居高不下排查解决与启示
· DeepSeek 开源周回顾「GitHub 热点速览」
· 白话解读 Dapr 1.15：你的「微服务管家」又秀新绝活了