PocketBase – Giải pháp backend mã nguồn mở nhẹ và mạnh mẽ

# Kiểm tra kiến trúc hệ thống
[[ "$(uname -m)" == "x86_64" ]] && echo "amd64" || echo "arm64"

# Tải phiên bản Linux amd64
wget https://github.com/pocketbase/pocketbase/releases/download/v0.31.0/pocketbase_0.31.0_linux_amd64.zip

# Linux/macOS
unzip pocketbase_0.31.0_linux_amd64.zip -d pocketbase

# Di chuyển vào thư mục
cd pocketbase

# Linux/macOS - Cấp quyền thực thi
chmod +x pocketbase

# Khởi động server
./pocketbase serve

pocketbase.exe serve

./pocketbase superuser create [email protected] MatKhau123

# Kết nối SSH
ssh root@<your_server_ip>

# Update system
apt update && apt upgrade -y && apt install -y unzip

# Tạo user riêng cho PocketBase
adduser pocketbase

# Chuyển sang user pocketbase
su - pocketbase

# Tải PocketBase (kiểm tra phiên bản mới nhất trên GitHub)
wget https://github.com/pocketbase/pocketbase/releases/download/v0.31.0/pocketbase_0.31.0_linux_amd64.zip

# Giải nén
unzip pocketbase_0.31.0_linux_amd64.zip

# Cấp quyền thực thi
chmod +x pocketbase

# Quay lại root user
exit

# Cho phép PocketBase bind port dưới 1024 (ví dụ: port 80, 443)
setcap CAP_NET_BIND_SERVICE=+eip /home/pocketbase/pocketbase

# Tạo systemd service file
cat <<EOF > /etc/systemd/system/pocketbase.service
[Unit]
Description=PocketBase
After=network-online.target

[Service]
User=pocketbase
WorkingDirectory=/home/pocketbase
ExecStart=/home/pocketbase/pocketbase serve --http=0.0.0.0:80
Restart=always
RestartSec=5

[Install]
WantedBy=multi-user.target
EOF

# Reload systemd
systemctl daemon-reload

# Enable service để tự động khởi động
systemctl enable pocketbase.service

# Khởi động service
systemctl start pocketbase.service

# Kiểm tra status
systemctl status pocketbase

# Chỉnh sửa service file
systemctl stop pocketbase
nano /etc/systemd/system/pocketbase.service

# Thay đổi ExecStart thành:
# ExecStart=/home/pocketbase/pocketbase serve --http=yourdomain.com:80 --https=yourdomain.com:443

systemctl daemon-reload
systemctl start pocketbase

# Cài đặt Nginx
apt install nginx -y

# Tạo config file
cat <<'EOF' > /etc/nginx/sites-available/pocketbase
server {
    listen 80;
    server_name vnrom.net;

    location / {
        proxy_pass http://localhost:8090;
        proxy_http_version 1.1;
        proxy_set_header Upgrade $http_upgrade;
        proxy_set_header Connection 'upgrade';
        proxy_set_header Host $host;
        proxy_cache_bypass $http_upgrade;
    }
}
EOF

# Enable site
ln -s /etc/nginx/sites-available/pocketbase /etc/nginx/sites-enabled/
nginx -t
systemctl restart nginx

# Cài đặt SSL với Certbot
apt install certbot python3-certbot-nginx -y
certbot --nginx -d vnrom.net

version: "3.7"
services:
  pocketbase:
    image: ghcr.io/muchobien/pocketbase:latest
    container_name: pocketbase
    restart: unless-stopped
    command:
      - --encryptionEnv
      - ENCRYPTION
    environment:
      ENCRYPTION: YOUR_32_CHARACTER_ENCRYPTION_KEY_HERE
    ports:
      - "8090:8090"
    volumes:
      - ./pb_data:/pb_data
      - ./pb_public:/pb_public
      - ./pb_migrations:/pb_migrations
    healthcheck:
      test: wget --no-verbose --tries=1 --spider http://localhost:8090/api/health || exit 1
      interval: 5s
      timeout: 5s
      retries: 5

# Tạo encryption key (quan trọng!)
openssl rand -hex 16

# Cập nhật ENCRYPTION trong docker-compose.yml với key vừa tạo

# Khởi động
docker compose up -d --build

# Xem logs
docker compose logs -f pocketbase

mkdir myapp
cd myapp

# Tạo main.go file
cat <<'EOF' > main.go
package main

import (
    "log"

    "github.com/pocketbase/pocketbase"
    "github.com/pocketbase/pocketbase/core"
)

func main() {
    app := pocketbase.New()

    // Custom route example
    app.OnServe().BindFunc(func(se *core.ServeEvent) error {
        se.Router.GET("/hello/:name", func(re *core.RequestEvent) error {
            name := re.Request.PathValue("name")
            return re.String(200, "Hello "+name)
        })
        return se.Next()
    })

    if err := app.Start(); err != nil {
        log.Fatal(err)
    }
}
EOF

# Initialize Go modules
go mod init myapp
go mod tidy

# Development mode
go run main.go serve

# Production build (static binary)
CGO_ENABLED=0 go build

# Chạy binary
./myapp serve

# Thay đổi port mặc định
./pocketbase serve --http=127.0.0.1:8091

# Cấp quyền thực thi
chmod +x pocketbase

# Nếu bind port < 1024 bị lỗi
sudo setcap CAP_NET_BIND_SERVICE=+eip ./pocketbase

// pb_migrations/1234567890_created_posts.js
migrate((app) => {
  const collection = new Collection({
    name: "posts",
    type: "base",
    schema: [
      {
        name: "title",
        type: "text",
        required: true,
      },
      {
        name: "content",
        type: "text",
      },
      {
        name: "author",
        type: "relation",
        options: {
          collectionId: "_pb_users_auth_", // Users collection
        }
      }
    ]
  });

  return app.save(collection);
}, (app) => {
  // Revert migration
  const collection = app.findCollectionByNameOrId("posts");
  return app.delete(collection);
});

import PocketBase from 'pocketbase';

const pb = new PocketBase('http://127.0.0.1:8090');

// Tạo record đơn giản
const record = await pb.collection('posts').create({
    title: 'Bài viết đầu tiên',
    content: 'Nội dung bài viết...',
});

console.log(record.id); // ID của record mới tạo

// Từ HTML file input
const fileInput = document.getElementById('fileInput');
const formData = new FormData();

formData.append('title', 'Bài viết có hình');
formData.append('content', 'Nội dung...');

// Upload nhiều files
for (let file of fileInput.files) {
    formData.append('images', file);
}

const record = await pb.collection('posts').create(formData);

// Lấy 20 records đầu tiên
const resultList = await pb.collection('posts').getList(1, 20, {
    filter: 'title != ""',  // Filtering
    sort: '-created',        // Sắp xếp theo ngày tạo (mới nhất)
    expand: 'author',        // Expand relations
});

console.log(resultList.items);
console.log(resultList.totalItems);

const record = await pb.collection('posts').getOne('RECORD_ID', {
    expand: 'author,comments',
});

console.log(record.title);
console.log(record.expand.author.email);

const record = await pb.collection('posts').update('RECORD_ID', {
    title: 'Tiêu đề mới',
    content: 'Nội dung đã cập nhật',
});

await pb.collection('posts').delete('RECORD_ID');

const userData = {
    email: '[email protected]',
    password: 'MatKhau123',
    passwordConfirm: 'MatKhau123',
    name: 'Nguyễn Văn Duy',
};

const record = await pb.collection('users').create(userData);

// Gửi email verification (nếu đã enable)
await pb.collection('users').requestVerification('[email protected]');

const authData = await pb.collection('users').authWithPassword(
    '[email protected]',
    'MatKhau123'
);

// Truy cập auth data
console.log(pb.authStore.isValid);   // true
console.log(pb.authStore.token);     // JWT token
console.log(pb.authStore.record.id); // User ID
console.log(pb.authStore.record.email);

// Mở popup OAuth2
const authData = await pb.collection('users').authWithOAuth2({
    provider: 'google'
});

// authData chứa token và user record
console.log(authData.record.email);

// Bước 1: Request OTP
const result = await pb.collection('users').requestOTP('[email protected]');

// Bước 2: User nhập code từ email
const otpCode = '123456'; // Code từ email

// Bước 3: Xác thực với OTP
const authData = await pb.collection('users').authWithOTP(
    result.otpId,
    otpCode
);

try {
    // Bước 1: Đăng nhập bình thường
    await pb.collection('users').authWithPassword('[email protected]', 'MatKhau123');
} catch (err) {
    // Nếu MFA được enable, sẽ nhận được mfaId
    const mfaId = err.response?.mfaId;

    if (mfaId) {
        // Bước 2: Yêu cầu OTP cho bước xác thực thứ 2
        const result = await pb.collection('users').requestOTP('[email protected]');

        // Bước 3: Xác thực với OTP + mfaId
        const authData = await pb.collection('users').authWithOTP(
            result.otpId,
            'OTP_CODE',
            { mfaId: mfaId }
        );
    }
}

// Đăng xuất
pb.authStore.clear();

// Kiểm tra đăng nhập
if (pb.authStore.isValid) {
    console.log('User đang đăng nhập:', pb.authStore.record.email);
}

// Refresh token tự động
pb.authStore.onChange((token, record) => {
    console.log('Auth state changed:', token, record);
});

// Manual refresh token
await pb.collection('users').authRefresh();

// Subscribe đến tất cả records trong collection
await pb.collection('posts').subscribe('*', (e) => {
    console.log('Realtime event:', e.action); // create, update, delete
    console.log('Record:', e.record);
});

// Subscribe đến một record cụ thể
await pb.collection('posts').subscribe('RECORD_ID', (e) => {
    console.log('Record updated:', e.record);
});

// Chỉ nhận updates cho records thỏa điều kiện
await pb.collection('posts').subscribe('*', (e) => {
    console.log('Post event:', e.record);
}, {
    filter: 'status = "published"',
    expand: 'author',
});

// Unsubscribe từ collection
await pb.collection('posts').unsubscribe('*');

// Unsubscribe tất cả
await pb.realtime.unsubscribe();

// Component: Chat.js
import { useEffect, useState } from 'react';
import PocketBase from 'pocketbase';

const pb = new PocketBase('http://127.0.0.1:8090');

function Chat() {
    const [messages, setMessages] = useState([]);

    useEffect(() => {
        // Fetch initial messages
        pb.collection('messages').getList(1, 50, {
            sort: 'created',
        }).then(result => {
            setMessages(result.items);
        });

        // Subscribe to new messages
        pb.collection('messages').subscribe('*', (e) => {
            if (e.action === 'create') {
                setMessages(prev => [...prev, e.record]);
            }
        });

        // Cleanup
        return () => {
            pb.collection('messages').unsubscribe('*');
        };
    }, []);

    const sendMessage = async (text) => {
        await pb.collection('messages').create({
            text: text,
            user: pb.authStore.record.id,
        });
    };

    return (
        <div>
            {messages.map(msg => (
                <div key={msg.id}>{msg.text}</div>
            ))}
        </div>
    );
}

// listRule & viewRule
@request.auth.id != ""  // Chỉ user đã đăng nhập

// createRule
@request.auth.id != ""

// updateRule & deleteRule
@request.auth.id = author.id  // Chỉ tác giả

// Tất cả rules
@request.auth.id = owner.id

// listRule & viewRule
""  // Không điều kiện = public

// createRule, updateRule, deleteRule
@request.auth.role = "admin"

// lib/pocketbase.js
import PocketBase from 'pocketbase';

const pb = new PocketBase(process.env.NEXT_PUBLIC_POCKETBASE_URL || 'http://127.0.0.1:8090');

export default pb;

// hooks.server.js
import PocketBase from 'pocketbase';
import { env } from '$env/dynamic/private';

export const handle = async ({ event, resolve }) => {
    event.locals.pb = new PocketBase(env.PB_URL);

    // Load auth từ cookie
    event.locals.pb.authStore.loadFromCookie(event.request.headers.get('cookie') || '');

    try {
        if (event.locals.pb.authStore.isValid) {
            await event.locals.pb.collection('users').authRefresh();
        }
    } catch (_) {
        event.locals.pb.authStore.clear();
    }

    const response = await resolve(event);

    // Save auth to cookie
    response.headers.append('set-cookie', event.locals.pb.authStore.exportToCookie());

    return response;
};

// plugins/pocketbase.js
import PocketBase from 'pocketbase';

export default defineNuxtPlugin(() => {
    const pb = new PocketBase('http://127.0.0.1:8090');

    return {
        provide: {
            pb
        }
    };
});

// Định nghĩa types cho collections
interface Post {
    id: string;
    title: string;
    content: string;
    author: string;
    created: string;
    updated: string;
}

interface User {
    id: string;
    email: string;
    name: string;
    avatar?: string;
}

// Type-safe collections
interface TypedPocketBase extends PocketBase {
    collection(name: 'posts'): RecordService<Post>;
    collection(name: 'users'): RecordService<User>;
    collection(name: string): RecordService; // Fallback
}

const pb = new PocketBase('http://127.0.0.1:8090') as TypedPocketBase;

// Autocomplete và type checking
const posts = await pb.collection('posts').getList<Post>(1, 20);
posts.items.forEach(post => {
    console.log(post.title); // Type-safe
});

# Tăng file descriptors (Linux)
ulimit -n 65536

# Hoặc cấu hình vĩnh viễn trong /etc/security/limits.conf
echo "* soft nofile 65536" >> /etc/security/limits.conf
echo "* hard nofile 65536" >> /etc/security/limits.conf

# Stop PocketBase
systemctl stop pocketbase

# Backup pb_data
tar -czf pb_data_backup_$(date +%Y%m%d).tar.gz pb_data/

# Restart
systemctl start pocketbase

systemctl stop pocketbase
tar -xzf pb_data_backup_20250101.tar.gz
systemctl start pocketbase

# Realtime logs
journalctl -u pocketbase -f

# Logs từ thời điểm cụ thể
journalctl -u pocketbase --since "2025-01-01"

./pocketbase serve --dev