PHP开发日志

test

Sun, 14 Sep 2025 11:41:14 +0800

SAAS多租户模型内容

Wed, 02 Apr 2025 20:04:00 +0800

1. 租户生命周期管理

租户创建流程：

注册页面需要支持租户基本信息的收集（如公司名称、联系人信息、初始管理员账号等）。

支持为租户分配唯一的子域名或自定义域名。

自动化流程：租户创建后，可能需要初始化数据库、配置默认数据（如初始用户角色、权限等）。

租户状态管理：

状态字段（如 active、suspended、expired 等），用于标识租户的状态。

提供手动或自动化的状态切换逻辑（例如到期后自动暂停）。

租户删除与归档：

提供软删除功能，允许将租户归档而不是直接删除。

归档后的租户数据可以保留一段时间，以备后续恢复或审计。

2. 计费与支付管理

套餐管理：

定义不同的套餐计划（如免费版、基础版、高级版等），每个套餐可以包含不同的功能限制（如用户数量、存储空间、API 请求次数等）。

支持动态调整套餐（升级/降级）。

续费与试用期：

支持试用期设置，并在试用期结束前提醒租户续费。

提供自动续费选项（通过支付网关实现）。

支付网关集成：

集成主流支付网关（如 Stripe、PayPal、支付宝、微信支付等）。

记录支付历史和发票信息。

账单与发票管理：

生成详细的账单记录，包括费用明细、支付状态、发票下载链接等。

支持导出 PDF 格式的发票。

3. 域名管理

子域名分配：

自动生成租户的子域名（如 tenant1.example.com）。

允许租户自定义子域名（如 custom-name.example.com）。

自定义域名绑定：

支持租户绑定自己的域名（如 tenant1.com）。

提供 DNS 设置指南（如 CNAME 或 A 记录指向你的服务器）。

SSL 证书管理：

自动为租户的子域名或自定义域名申请 SSL 证书（推荐使用 Let's Encrypt）。

监控证书的有效期并自动续期。

4. 租户资源隔离与限制

数据库隔离：

使用 stancl/tenancy 的多数据库模式，确保每个租户的数据完全隔离。

文件存储隔离：

配置独立的文件存储路径或 S3 存储桶，避免不同租户之间的文件冲突。

资源配额限制：

对租户的资源使用进行限制（如存储空间、带宽、并发连接数等）。

提供实时监控和告警功能。

5. 租户管理面板

租户信息概览：

显示租户的基本信息（如公司名称、联系人、创建时间等）。

显示当前套餐、有效期、支付状态等。

活动日志：

记录租户的操作日志（如登录、修改配置等）。

提供搜索和过滤功能，方便排查问题。

权限管理：

为每个租户分配独立的管理员账户，并支持多角色权限管理。

允许租户管理员自行管理其团队成员。

6. 通知与提醒

邮件通知：

在租户即将到期、支付失败或发生异常时发送邮件提醒。

站内消息：

提供站内消息系统，向租户管理员发送重要通知。

短信/推送通知：

集成短信服务或推送通知服务（如 Twilio、Firebase Cloud Messaging），以覆盖更多通知场景。

7. 安全与合规

数据隐私与备份：

定期备份租户数据，并提供数据恢复功能。

遵守 GDPR 或其他相关法规，确保租户数据的安全和隐私。

身份验证与授权：

实现强大的身份验证机制（如双因素认证）。

确保租户之间的权限隔离，避免越权访问。

日志与审计：

记录所有关键操作（如租户创建、删除、支付等）。

提供审计日志查询功能，便于追踪和分析。

8. 扩展功能

多语言支持：

为租户提供多语言界面支持，满足国际化需求。

自定义主题：

允许租户自定义其 SAAS 应用的外观（如颜色、Logo 等）。

API 接口：

提供 API 接口，让租户能够通过编程方式与其数据交互。

确保 API 的安全性（如使用 OAuth2 或 API 密钥）。

数据分析与报表：

提供租户使用情况的统计报表（如活跃用户数、资源消耗等）。

帮助租户更好地了解其业务表现。

9. 性能与扩展性

缓存优化：

使用 Redis 或 Memcached 缓存常用数据，提升性能。

队列处理：

将耗时任务（如发送邮件、生成报告等）放入队列中异步处理。

水平扩展：

设计可扩展的架构，支持多服务器部署以应对高并发场景。

10. 文档与支持

帮助中心：

提供详细的帮助文档，指导租户如何使用系统。

客户支持：

提供在线客服或工单系统，快速响应租户的问题。

开发者工具：

如果你的 SAAS 系统面向开发者，可以提供 SDK、API 文档和示例代码。

alpine.js Jquery Vue

Thu, 02 Jan 2025 08:22:27 +0800

Alpine.js 是一个轻量级的 JavaScript 框架，适用于开发简单、交互性要求不太复杂的网页。下面是一些适合使用 Alpine.js 开发的网页场景：

小型项目或页面： Alpine.js 非常适合开发小型项目或简单的单页面应用（SPA），因为它的体积很小，加载速度快，不需要像其他大型框架那样复杂的构建和配置。
表单交互： 如果你需要为网页添加一些表单交互功能，比如输入验证、动态显示/隐藏表单字段等，Alpine.js 是一个很好的选择。它的数据绑定和事件监听能力使得处理表单交互变得简单而高效。
条件渲染： 当需要根据特定条件显示或隐藏一些元素时，比如根据用户的登录状态展示不同的界面，使用 Alpine.js 的 x-show 或 x-if 指令可以轻松实现条件渲染。
简单动画效果： Alpine.js 支持简单的动画效果，通过 x-transition 和 x-show 结合使用，可以实现一些基本的元素过渡效果。
增强现有页面： 如果你已经有一个静态页面，但希望在其中添加一些交互性功能而不想引入整个大型框架，那么可以使用 Alpine.js 来为现有页面增加交互性。
快速原型开发： 当你需要快速构建一个原型或演示页面时，Alpine.js 提供了简单而快速的开发方式，让你可以迅速验证概念和想法。

请注意，由于 Alpine.js 的定位是轻量级框架，对于复杂的应用程序或大规模的项目，你可能需要考虑更为功能丰富的框架，比如 Vue.js、React 或 Angular。这些框架提供更多高级特性和更好的可扩展性，适合构建大型和复杂的应用程序。

综上所述，Alpine.js 是一个优秀的选择，特别适用于小型项目、简单页面、表单交互和快速原型开发等场景。

那么我项目已经使用了jquery还需要使用alpine.js吗?

Alpine.js 和 jQuery 都是用于前端开发的 JavaScript 库，但它们在设计理念、用法和特点上有很大的区别。下面是对比 Alpine.js 和 jQuery 的描述解析：

设计理念：

Alpine.js：Alpine.js 是一个轻量级的 JavaScript 框架，专注于在现有 HTML 上增强交互性和动态功能。它的设计哲学是"更少的 JavaScript"，通过在 HTML 中使用指令和表达式来实现交互功能，而不是通过 JavaScript 代码来操作 DOM。这样可以使开发过程更简单、更直观，同时保持 HTML 和 JavaScript 的分离。
jQuery：jQuery 是一个功能强大且广泛应用的 JavaScript 库，旨在简化 DOM 操作和处理事件。它提供了许多便捷的 API，使得选择元素、添加动画、处理事件等操作更加简单。它在较早的 Web 开发中非常流行，但随着现代浏览器的发展和原生 JavaScript API 的增强，jQuery 的地位逐渐被其他框架和库取代。

使用方式：

Alpine.js：Alpine.js 的使用方式非常简单，你只需将 Alpine.js 文件引入到 HTML 中，然后在元素上添加指令和表达式即可。它不需要特定的构建工具，也不需要学习新的 API，可以很方便地与现有项目集成。
jQuery：使用 jQuery 需要先将 jQuery 库文件引入到 HTML 中，然后通过选择器选择元素并使用 jQuery 提供的方法来操作 DOM、添加事件处理等。虽然 jQuery 提供了方便的 API，但它的使用仍然需要学习一些特定的语法和方法。

体积和性能：

Alpine.js：Alpine.js 的体积非常小，仅有几 KB 大小，因此加载速度很快。由于它的设计理念是"更少的 JavaScript"，在性能方面表现很好，特别适合用于小型项目和简单页面。
jQuery：相比于 Alpine.js，jQuery 的体积较大，虽然现代浏览器已经对其进行了缓存优化，但仍然比 Alpine.js 大很多。在性能方面，jQuery 提供了许多功能，有时可能会带来不必要的性能开销，特别是在现代浏览器已经原生支持许多常见操作的情况下。

适用场景：

Alpine.js：适用于小型项目、简单页面、表单交互、增强现有页面和快速原型开发等场景。它更加轻量，适合那些不需要复杂功能的项目。
jQuery：在较早的 Web 开发中，jQuery 非常流行，适用于需要处理大量 DOM 操作和事件的项目。然而，现在在很多情况下，原生 JavaScript 已经能够胜任 jQuery 的任务，并且更为高效。

总的来说，Alpine.js 和 jQuery 都有各自的优势和适用场景。如果你需要在现有 HTML 中增加一些交互功能，尤其是对于小型项目和简单页面，Alpine.js 是一个很好的选择。而对于复杂的项目和大规模的应用程序，可能更适合使用现代的前端框架，或者在不需要考虑兼容性的情况下，直接使用原生 JavaScript。

nuxtjs3 自定义$fetch pinia组合数据预取

Wed, 05 Jun 2024 22:49:26 +0800

//'~/plugins/piniaFetchPlugin.ts',

import { defineNuxtPlugin } from '#app'
import { useRuntimeConfig } from '#imports'
import { PiniaPluginContext } from 'pinia'

export default defineNuxtPlugin((nuxtApp) => {
nuxtApp.$pinia.use(({ store }: PiniaPluginContext) => {
store.$fetch = async (fetcher: () => Promise<void>) => {
if (process.server) {
await fetcher()
}
}
})
})

使用

<div>

<p v-else>Loading...</p>

</div>

</template>

import { useExampleStore } from '@/stores/example'

// 获取store实例

const store = useExampleStore()

// 在setup中预取数据

await store.$fetch(store.fetchData)

// 使用store中的数据

const data = store.$state.data

</script>

配置：

plugins: [
'~/plugins/piniaFetchPlugin.ts',
],

要通过Docker镜像来配置Vue Storefront运行环境，请按照以下步骤操作：

Fri, 26 Jan 2024 23:01:41 +0800

### 1. 准备Dockerfile

首先，您需要一个Dockerfile来构建包含Vue Storefront及其依赖的镜像。Dockerfile通常会从Node.js基础镜像开始，并执行安装Vue Storefront和其依赖、打包应用以及配置Nginx等步骤。下面是一个基本示例：

```Dockerfile

# 使用官方Node.js镜像作为构建阶段的基础镜像

FROM node:latest AS build-stage

# 设置工作目录

WORKDIR /app/vue-storefront

# 将主机上的package.json和package-lock.json复制到容器中以安装依赖

COPY package*.json ./

# 安装项目依赖

RUN npm ci

# 复制剩余源代码到容器

COPY . .

# 执行构建命令（根据Vue Storefront的实际构建命令调整）

RUN npm run build

# 部署阶段使用nginx作为基础镜像

FROM nginx:alpine

# 删除默认配置文件

RUN rm -rf /etc/nginx/conf.d/default.conf

# 将nginx配置文件复制到容器内

COPY default.conf /etc/nginx/conf.d/

# 将编译好的Vue Storefront静态资源复制到nginx的web服务目录

COPY --from=build-stage /app/vue-storefront/dist /usr/share/nginx/html

# 暴露端口

EXPOSE 80

# 启动nginx

CMD ["nginx", "-g", "daemon off;"]

```

### 2. 编写Nginx配置文件 `default.conf`

创建一个名为 `default.conf` 的文件在项目根目录下，它将被复制到容器内的Nginx配置目录中：

```conf

server {

listen 80;

server_name storefront.example.com; # 替换为实际域名或服务器IP地址

location / {

root /usr/share/nginx/html;

index index.html;

try_files $uri $uri/ /index.html;

gzip on;

gzip_min_length 1k;

gzip_comp_level 5;

gzip_types text/plain text/css application/json application/javascript text/xml application/xml application/xml+rss text/javascript;

}

error_page 500 502 503 504 /50x.html;

location = /50x.html {

root /usr/share/nginx/html;

}

```

### 3. 构建Docker镜像

确保您的Vue Storefront项目已正确构建并准备好部署后，在终端中切换至包含Dockerfile的项目根目录，然后构建镜像：

```sh

docker build -t vue-storefront-app .

```

### 4. 运行Docker容器

构建完成后，运行Docker容器并将宿主机端口映射到容器内：

```sh

docker run -d -p 8080:80 --name vue-storefront-instance vue-storefront-app

```

这样就通过Docker创建了一个包含Vue Storefront运行环境的容器，并且可以在本地通过 `http://localhost:8080` 访问应用（如果映射的是8080端口）。

请根据实际情况调整上述步骤中的配置和命令。

1. Docker Compose 和 Dockerfile 的区别

Sat, 06 Jan 2024 19:15:34 +0800

1. Docker Compose 和 Dockerfile 的区别

Docker Compose 和 Dockerfile 都是用于构建和管理 Docker 容器的工具，但它们有着不同的作用和使用方式。

Dockerfile 是一个文本文件，用于定义 Docker 镜像的构建规则。它包含了一系列的指令，用于指定容器运行时的操作系统、软件环境、应用程序、文件拷贝等信息。通过 Dockerfile，可以构建出一个自定义的 Docker 镜像，使得该镜像能够在任意支持 Docker 的主机上运行。
Docker Compose 则是一个用于定义和运行多个 Docker 容器的工具。通过 Docker Compose，可以使用 YAML 文件来描述应用程序的服务、网络、存储等资源，并使用一个命令来启动、停止、重启和管理整个应用程序。在一个 Docker Compose 的配置文件中，可以定义多个 Docker 容器，每个容器都可以使用自定义的 Docker 镜像，并可以指定容器之间的依赖关系和通信方式。

因此，Dockerfile 更多地用于创建和定制 Docker 镜像，而 Docker Compose 更多地用于管理多个 Docker 容器，让它们能够协同工作来构建一个完整的应用程序。

2. 举例说明

假设你要在 CentOS 7 系统上运行一个 PHP Web 应用程序，并使用 Nginx 作为 Web 服务器，可以使用 Dockerfile 和 Docker Compose 来实现。

使用 Dockerfile，可以创建一个自定义的 PHP+Nginx 镜像，例如：

FROM php:7.4-fpm
RUN apt-get update && apt-get install -y nginx
COPY nginx.conf /etc/nginx/nginx.conf
WORKDIR /var/www/html
COPY src/ /var/www/html/
EXPOSE 80
CMD ["nginx", "-g", "daemon off;"]

该 Dockerfile 基于官方的 PHP 7.4-fpm 镜像，安装了 Nginx，并将应用程序代码复制到容器的 /var/www/html 目录下。该镜像还将容器的 80 端口映射到宿主机，以便可以从宿主机通过浏览器访问该应用程序。

使用 Docker Compose，可以定义一个 YAML 文件，来同时启动 PHP 和 Nginx 两个容器，并将它们连接到同一个 Docker 网络中。例如：

`version: '3'services:
  php:
    image: php:7.4-fpm    volumes:
      - ./src:/var/www/html    networks:
      - my-network  nginx:
    image: nginx:latest    ports:
      - "80:80"
    volumes:
      - ./nginx.conf:/etc/nginx/nginx.conf    networks:
      - my-networknetworks:
  my-network:`

该 Docker Compose 文件定义了两个服务：一个是基于官方的 PHP 7.4-fpm 镜像，另一个是基于官方的 Nginx 镜像。它们都挂载了本地的应用程序代码和 Nginx 配置文件，并将它们连接到一个名为 my-network 的 Docker 网络中。此外，Nginx 容器的 80 端口也映射到了宿主机的 80 端口上。

总的来说，Dockerfile 更适合创建和定制单个镜像，而 Docker Compose 更适合管理多个容器并将它们组合在一起构建一个完整的应用程序。在这个例子中，使用 Dockerfile 可以创建一个自定义的 PHP+Nginx 镜像，而使用 Docker Compose 可以同时启动 PHP 和 Nginx 两个容器，并将它们连接到同一个 Docker 网络中。

从零构建一个基于 Docker 的 Laravel 应用

Fri, 05 Jan 2024 23:11:38 +0800

Docker 简介

其实在这样的一个云计算时代, Docker 早就已被人众所周知了,它改变了传统物理机的虚拟化方式,使得机器的资源得到了高效的利用. 因为运行在 Docker 中的应用实际上就是运行在宿主机上的, 所以它是不需要进行硬件层面的虚拟化以及运行一个完整操作系统来支持. 于是在应用代码的执行效率, 内存的使用以及文件的读取速度都比传统虚拟化的方式来的强. 而且它的启动速度非常快,往往都是在毫秒级的,可以大大的节约了开发测试以及部署的时间. 其实对于开发人员来说, Docker 一个更大的意义就是可以保证拥有一致的运行环境, 程序员最常见的就是在开发测试部署环境不一致的情况下, 经常会触发一些莫名奇妙的BUG, 为了杜绝「这段代码在我机器上没问题啊」这类的问题,这也是我们要去学习 Docker 的理由之一.

如何学习 Docker

网上充斥着大量的关于 Docker 各个方面的教程和资料, 而且由于 Docker 的飞速发展, 很多教程其实都过时了, 对于初学者来说很难去分辨把握, 随之而来的就是一系列的坑与问题, 渐渐的磨灭了学习者的动力. 其实学习一门新技术最好的永远都是从官方的文档入手, 然后就是 GitHub 上面一个技术人员的学习笔记, 最重要的是要去摸索实践, 并且做好学习笔记. 其实学习一门新技术, 如果有正确的学习方法是可以少走很多弯路的, 这个有机会会写一篇心得.

快速入门

这里限制于篇幅和作者水平, 不会大谈 Docker 底层原理以及技术实现,也不会教你如何写一个繁琐的 Dockerfile, 而是会从一个普通开发者的身份入手, 带你从零搭建一个基于 Docker 的 Laravel 应用.我们的系统环境使用的是 Ubuntu17.04, 其他系统也差不多,当然 Window 的话可能就要另当别论了.

安装 Docker

在 Ubuntu 下 Docker 的安装和常规的软件一样,但是由于中国特色,还有有很多要注意的点,待会会详细说明. Docker 的安装方式有很多种，这里建议使用官方的一键安装脚本来，避免一系列繁琐的操作。

1. 下载安装

  curl -fsSL get.docker.com -o get-docker.sh

然后安装，并且选择从阿里镜像源下载：

sudo sh get-docker.sh --mirror Aliyun

2. 基本配置

其实安装后基本上就可以使用了，主要是配置一些镜像源和用户组。配置镜像源的目的不多说，用户组主要是为了再使用的时候不用使用超级管理员权限即可运行。

加入用户组

sudo usermod -aG docker $USER

PS. 配置用户组后，可能还是会出现还是提示没有权限的情况，这时重启机器即可

配置镜像源

sudo mkdir -p /etc/dockersudo tee /etc/docker/daemon.json <<-'EOF'{  "registry-mirrors": ["https://be62qq2e.mirror.aliyuncs.com"]}EOF

PS. 这里的镜像源是我自己阿里云的，同学们可以自行去阿里云获取专有镜像源地址

重启

sudo systemctl daemon-reloadsudo systemctl restart docker

3. 安装docker-compose

docker-compose类似一个包管理工具，方便我们管理镜像。

curl -L https://github.com/docker/compose/releases/download/1.17.1/run.sh > /usr/local/bin/docker-composechmod +x /usr/local/bin/docker-compose

基本概念

Docker 有两个很重要的基本概念就是镜像和容器. 这两个其实就类似面向对象中的类和实例. 镜像构建起来后就是容器,然后容器可以启动停止,对于运行于容器中的应用在运行过程中产生的数据,实际上是可以保留下来的,只要不销毁容器. 如果销毁或者重新构建容器后数据自然就不存在了,所以官方建议用挂载的方式来持久化, 接下来会说到.

docker-compose

docker-compose 可以说是真正的让 Docker 现代化了. 它就类似于 PHP 的 Composer 包管理工具一样, 是用来管理多个镜像的. 它极大的降低了学习 Docker 的难度. 我们在日常的开发中, 经常会碰到需要多个容器相互配合来完成某项任务的情况,比如 Web 容器和数据库容器之间的通信,我们可以单独的把一个项目中需要的所有容器和配置写到一个 docker-compose.yml 文件中,来统一管理.来看一下一个简单的配置文件格式:

version: '3'services:  nginx:    build: .    ports:     - "80:80"  redis:    image: "redis:alpine"

一个项目可以由多个服务(容器)工程，而 docker-compose 是面向项目进行管理.

文件系统和网络

这是 Docker 比较复杂的一块,简单介绍一下. Docker 里面的文件系统其实很真实宿主机的一样, 可以用同样的命令去操作, 只是要注意的一点就是我们在容器中运行的应用配置文件的路径全部都是基于 Docker 的,不是基于宿主机的,很多文件不存在的问题都是这个引起来的.比如我们在运行一个 Nginx 容器和 PHP-FPM 容器的时候,不仅要把宿主机的项目路径映射到 Nginx 容器中,还要映射到 PHP-FPM 容器中,否则就会是一系列的 File not found. Docker 中的网络是有多种模式的, 在默认情况下是会创建一个虚拟网桥的, 实际上是 Linux 的一个 bridge，它会在挂载到它的网口之间进行转发。并且会随机分配一个本地未被使用的属于 172.17.0.0/16 网段的 IP 到各个容器中.这是一个网络拓扑图:

部署 Laravel 应用

基本介绍后我们会通过一个简单的实例来加深理解, 就是部署一个 Laravel 应用. Web 服务器我们会使用 Nginx, 并且通过 PHP-FPM 来处理动态请求,用 MySQL 来存储数据, Redis 作为我们的缓存和队列驱动. 不同于网上的通过 Supervisor 来把所有服务运行在同一个容器中,我们会把这四个服务运行在四个容器中,这也是官方推荐的一种做法,然后我们会通过 docker-compose 来管理所有的服务(容器).

Nginx

直接上配置文件：

version: '2'services:    nginx:        image: nginx        ports:            - "8090:80"        links:            - php-fpm        volumes:          - ./nginx/www:/var/www/html          - ./nginx/sites:/etc/nginx/sites-enabled          - ./nginx/nginx.conf:/etc/nginx/nginx.conf        command: [nginx-debug, '-g', 'daemon off;']

其中的 services 节点下每一个表示一个服务；然后 nginx 这是个服务名可以随便取；image 指定使用哪个镜像来构建; ports 表示要暴露的端口，其中 8090 是指宿主机的端口，80 是指容器中的端口；volumes 表示挂载的目录和文件，我们这里挂载了代码目录，虚拟主机目录以及配置文件；command 表示容器启动后要运行的命令。我们还要在当前目录下创建一个 nginx 的目录，用来存放一系列的文件，还需要把配置文件新建并且写入配置内容(具体配置内容可以去官网查看，这里不说明)，最后的目录结构是这样

Docker    - docker-compose.yml    - nginx        - www        - sites        - nginx.conf

可以把日志一起挂载，这里没有表述出来

然后执行启动容器的命令：

docker-compose up nginx

以上不会在后台启动，而是会直接在当前的 shell 上，然后我们访问应该就可以看到 Welcome to nginx！

PHP-FPM、Redis、MySQL

同理我们再次配置 PHP-FPM，MySQL 以及 Redis 的容器了，具体过程不多讲，这里贴出配置：

  php-fpm:    image: 'bitnami/php-fpm:7.1'    volumes:      - ./nginx/www:/var/www/html      - ./php-fpm/php.ini:/bitnami/php/conf/php.ini    links:      - mysql      - redis  mysql:    image: mysql    restart: always    environment:        MYSQL_ROOT_PASSWORD: example    volumes:      - /var/lib/mysql:/var/lib/mysql  redis:    image: redis

有一点要注意的是，在配置PHP-FPM容器的时候是需要把代码目录也挂载到容器里面的，这一点很容易被遗忘，网上很多教程都没提到，导致最后虽然按照步骤走了但就是跑不起来。其中的 links 就是配置要连接到哪个容器中。比如配置了 Nginx 容器连接到 PHP-FPM 的容器，这样我们在 Nginx 的容器中就可以直接 ping php-fpm,在配置的时候也可以这样 php-fpm:9000 来配置了。

配置文件

Nginx 的配置文件，然后还要修改一下本地的 hosts 文件。

server {    listen 80;    listen [::]:80;    root /var/www/html/laravel/public;    index index.html index.php;    server_name laravel-docker.app;    location / {            try_files $uri $uri/ /index.php?$query_string;    }    location ~ \.php$ {            fastcgi_split_path_info ^(.+\.php)(/.+)$;            fastcgi_pass php-fpm:9000;            fastcgi_index index.php;            include fastcgi_params;            fastcgi_param SCRIPT_FILENAME $document_root$fastcgi_script_name;    }}

运行访问

附录

贴一些常用的 docker-compose 命令，其中的 dc 表示 docker-compose 命令。

dc  stop            停止所有容器dc  stop    nginx   停止指定容器dc  up      -d      启动容器后台运行dc  ps              查看当前容器dc  logs    kafka   查看指定容器日志

未命名

Sun, 21 May 2023 19:21:51 +0800

PHP接入chatGpt API

Wed, 22 Mar 2023 20:46:33 +0800

蹭个热度，写个chatGPT API PHP接入

$query = "Hello, ChatGPT!";  // 查询内容
$api_key = "your_api_key";   // API Key

// 准备请求数据
$data = array(
   'query' => $query,
);

// 发送HTTP请求
$ch = curl_init();
curl_setopt($ch, CURLOPT_URL, "https://api.chatgpt.com/v1/gpt3");
curl_setopt($ch, CURLOPT_POST, 1);
curl_setopt($ch, CURLOPT_POSTFIELDS, $data);
curl_setopt($ch, CURLOPT_RETURNTRANSFER, 1);
curl_setopt($ch, CURLOPT_HTTPHEADER, array(
   'API-KEY: '.$api_key,
));
$response = curl_exec($ch);
curl_close($ch);

// 处理API响应
if ($response === false) {
   echo "API请求失败！";
} else {
   // 将API响应转换为PHP数组
   $result = json_decode($response, true);
   if ($result && isset($result["success"]) && $result["success"] == true) {
       // 处理API成功响应的数据
       $data = $result["data"];
       // 保存对话历史记录
       saveDialogue($query, $data["text"]);
       // 检查敏感词汇
       if (checkSensitiveWords($data["text"])) {
           // 如果检测到敏感词汇，做出相应处理
           handleSensitiveWords($data["text"]);
       } else {
           // 输出生成的对话文本
           echo $data["text"];
       }
   } else {
       // 处理API响应错误信息
       $error = $result["error"]["message"];
       echo "API请求错误：".$error;
   }
}

// 保存对话历史记录
function saveDialogue($query, $response) {
   // TODO: 保存对话历史记录
   $file = fopen("dialogue_history.txt", "a");
   fwrite($file, "Query:".$query."\tResponse:".$response."\n");
   fclose($file);
}

// 检查敏感词汇
function checkSensitiveWords($text) {
   // TODO: 检查敏感词汇
   if (strpos($text, "敏感词汇") !== false) {
       return true;
   } else {
       return false;
   }
}

// 处理敏感词汇
function handleSensitiveWords($text) {
   // TODO: 处理敏感词汇
   echo "您的请求包含敏感词汇，请重新输入。";
}

Linux进程间管道通信

Fri, 28 Oct 2022 10:41:14 +0800

无名管道：

无名管道的特点：

只能用于具有亲缘关系间的通信。【父子进程或兄弟进程】

半双工通信。【只能由一方发送，另一方接收】

通信端口固定。【fd[0]:读管道，fd[1]:写管道】

管道也是一种特殊的文件，对于它的读写，也可以使用普通的read(),write()函数。

管道不属于任何文件系统，只存在于内存中。

无名管道的创建

无名管道是基于文件描述符的通信方式,当一个管道被建立时，它会创建两个文件描述符：fd[0]、fd[1].
fd[0]:读文件描述符，用于固定读管道
fd[1]:写文件描述符，用于固定写管道

无名管道的相关函数

头文件：#include<unistd.h>
函数名：pipe
参数：int pipefd[] :包含两个元素的整型数组，存
放管道对应的文件描述符
返回值：成功--> 0 失败--> -1

int pipe(int pipefd[]);

pipe函数创建的管道两端处于同一个进程中。由于管道主要是用于不同进程间的通信，所以首先会fork()一个子进程，该子进程会继承父进程所创建的管道。此时父子进程就都拥有了一个管道，所以会产生两个fd[0],fd[1]。

根据需要，若是父进程发消息，子进程收消息。那么久关闭父进程的fd[1]，关闭子进程的fd[0]。此时父进程就只有fd[0],子进程也就只有fd[1]了。他们俩就能通过无名管道来进行单向通信。

同理，若是需要子进程发送数据，父进程接收数据，就关闭对应的文件描述符即可。

举个栗子

注意事项：

只有管道的读端存在时，向管道内写入数据才有意义。否则，向管道内写入的数据的进程会收到内核传来的SIGPIPE信号。【通常为Broken Pipe(管道破裂) 错误】

向管道内写入数据时，Linux不保证写入的原子性，管道缓冲区只要有空间，写进程就会向管道写入数据；若管道已满，则写操作会阻塞等待

父子进程在运行时，他们的先后次序不能保证。为确保父子进程已经关闭了相应的文件描述符，可以在两个进程中调用 sleep()函数

【附】上述例子的源码：

#include<stdio.h>
#include<unistd.h>
#include<string.h>

int main(void)
{
pid_t pid = -1;
int pipefd[2];
//创建无名管道
if(0 > pipe(pipefd))
{
perror("pipe error!\n");
return -1;
}
puts("pipe success!");
/*pipe[0]读端 , pipe[1]写端*/
pid = fork();//创建子进程
//判断是否创建成功
if(0 > pid)//pid错误
{
perror("fork error!\n");
return -1;
}
else if(0 < pid)
{
//父进程发子进程收
close(pipefd[0]);//关闭父进程的读端fd[0]
//发送数据
char buf[20] = {0};
//从键盘输入小于20的字符串
gets(buf , sizeof(buf) , stdin);
//将获得的字符串通过管道传递给子进程(pipefd[1]是子进程的接收端)
write(pipefd[1] , buf , strlen(buf));
//关闭父进程的写文件描述符
close(pipefd[1]);
}
else if(0 == pid)
{
//子进程
close(pipefd[1]);//关闭子进程的写端fd[1]
//接收数据
char buf1[20] = {0};
read(pipefd[0] , buf1 , sizeof(buf1));

printf("read data : %s\n" , buf1);
//关闭读端
close(pipefd[0]);

}
return 0;
}

#include <stdio.h>
#include <unistd.h>
#include <string.h>
#include <stdlib.h>
//-----------------------------------------------示例二--------------------------------------------//
int main()
{
int fd[2];

int pid;

char readbuf[128];

if(pipe(fd) == -1){
printf("creat pipe fail\n");
}

pid = fork();

if(pid < 0){
printf("creat child fail\n");
}
else if(pid > 0){
printf("this is father\n");
sleep(3);
close(fd[0]);
write(fd[1],"hellow this father",strlen("hellow this father"));
wait();
}else{
printf("this is child\n");
close(fd[1]);
read(fd[0],readbuf,128);
printf("this is from father:%s\n",readbuf);
exit(0);
}
return 0;
}