Kebenaran adalah penting semasa membina aplikasi, kerana ia menentukan tindakan dan sumber yang dibenarkan untuk diakses oleh pengguna selepas mereka mengesahkannya.
Dalam artikel ini, kita akan melihat cara melaksanakan kebenaran menggunakan permit.io. Untuk menunjukkannya, kami akan membina apl kedai buku ringkas menggunakan Golang dan HTMX (saya peminat tegar).
Untuk mengikuti tutorial ini, prasyarat berikut harus dipenuhi:
Semua pengguna (termasuk pentadbir) boleh membaca buku. Pentadbir juga boleh menambah, memadam dan mengemas kini buku. Pengguna standard terhad kepada membaca buku.
Tutorial ini akan membimbing anda melalui penyediaan aplikasi kedai buku dengan kebenaran asas. Kami akan melaksanakan:
Logik Kebenaran: Tentukan peranan (Pentadbir dan Pengguna Standard) menggunakan Permit.io untuk menyekat atau memberikan akses kepada sumber yang berbeza.
Pangkalan Data: Sediakan pangkalan data PostgreSQL untuk menyimpan data buku dan pengguna.
Pengendali: Laksanakan laluan untuk melihat, menambah, mengemas kini dan memadamkan buku dengan semakan kawalan akses.
Hadapan: Gunakan HTMX untuk memuatkan data buku secara dinamik.
Dalam menyediakan projek, kami akan bermula dengan menyediakan permit.io. Navigasi ke ruang kerja papan pemuka anda dan buat projek baharu. Saya akan beri nama kedai buku saya.
Ini akan mewujudkan dua persekitaran: persekitaran pembangunan dan persekitaran pengeluaran.
Memandangkan kami bekerja secara tempatan, kami akan menggunakan persekitaran pembangunan. Klik pada Buka papan pemuka dalam persekitaran Pembangunan dan kemudian pada Cipta Dasar. Anda akan diminta membuat sumber baharu dahulu. Klik buat sumber. Beri nama dan nyatakan tindakan. Untuk projek ini, saya akan menamakan buku saya, dan tindakannya ialah mencipta, mengemas kini, memadam dan melihat.
Seterusnya, navigasi ke bahagian editor dasar. Secara lalai, anda sepatutnya melihat peranan pentadbir telah dibuat. Anda hanya perlu menandai tindakan paparan yang kami tambahkan, kerana tindakan tersebut tidak dikenali secara lalai. Anda perlukan peranan lain. Ini adalah untuk pengguna dengan kebenaran membaca sahaja.
Klik Cipta kemudian Peranan dan berikannya nama pengguna. Setelah dibuat, anda harus melihatnya dalam editor dasar dan tandakan paparan dalam peranan pengguna yang baru anda buat seperti:
Perkara seterusnya ialah mendaftarkan pengguna yang akan diberi kuasa oleh permit.io. Navigasi kembali ke menu utama anda melalui menu bar sisi anda masih sepatutnya mempunyai sesuatu seperti ini:
Klik pada Tambah pengguna dan kemudian tambah, kemudian tambah pengguna. Isikan butiran yang sepadan dengan pengguna anda dalam pangkalan data.
Setelah itu selesai, navigasi kembali ke projek anda. Dalam Pembangunan Untuk persekitaran untuk projek kedai buku, klik pada ikon 3 titik. Anda akan melihat pilihan untuk menyalin kunci API. Salin dan simpannya di suatu tempat, kerana anda akan memerlukannya untuk projek.
Buat pangkalan data PostgreSQL yang dipanggil kedai buku. Anda perlu menyediakan dua jadual:
CREATE TABLE users ( id SERIAL PRIMARY KEY, username VARCHAR(255) NOT NULL, password_hash VARCHAR(255) NOT NULL, role VARCHAR(50) NOT NULL );
Teruskan dan isikan ini, tetapi jadikan setiap pengguna mempunyai peranan sebagai pentadbir dan pengguna, masing-masing, dan pastikan mereka sepadan dengan pengguna yang ditambahkan pada Permit.io.
CREATE TABLE books ( id UUID PRIMARY KEY DEFAULT gen_random_uuid(), title VARCHAR(255) NOT NULL, author VARCHAR(255) NOT NULL, published_at DATE, created_at TIMESTAMPTZ DEFAULT now() );
Anda tidak perlu mengisi ini, kami akan melakukannya dalam kod.
Anda perlu memasang kebergantungan berikut:
github.com/permitio/permit-golang: Menyediakan alatan untuk mengendalikan kawalan akses berasaskan peranan (RBAC) dan pengurusan kebenaran dengan aplikasi Permit.io dalam Go.
github.com/google/uuid: Ini menyediakan fungsi untuk menjana dan berfungsi dengan pengecam unik universal (UUID).
github.com/gorilla/mux: Membantu Melaksanakan penghala permintaan HTTP dan penghantar untuk mengendalikan laluan dalam aplikasi web.
github.com/joho/godotenv: Ini memuatkan pembolehubah persekitaran daripada .env. fail ke dalam aplikasi, menjadikannya lebih mudah untuk mengurus tetapan konfigurasi.
github.com/lib/pq: Ini ialah pemacu Postgres Go untuk berkomunikasi dengan pangkalan data PostgreSQL.
golang.org/x/crypto: Melaksanakan algoritma kriptografi tambahan dan pustaka yang tidak disertakan dalam pustaka standard Go.
Untuk memasang kebergantungan ini, anda perlu memulakan permulaan modul Go baharu. Ini adalah titik permulaan untuk pengurusan pergantungan dalam Go.
Jalankan arahan ini:
CREATE TABLE users ( id SERIAL PRIMARY KEY, username VARCHAR(255) NOT NULL, password_hash VARCHAR(255) NOT NULL, role VARCHAR(50) NOT NULL );
Seterusnya, jalankan arahan ini:
CREATE TABLE books ( id UUID PRIMARY KEY DEFAULT gen_random_uuid(), title VARCHAR(255) NOT NULL, author VARCHAR(255) NOT NULL, published_at DATE, created_at TIMESTAMPTZ DEFAULT now() );
Ini akan memasang semua kebergantungan yang disenaraikan di atas.
Untuk menyediakan PDP, anda perlu memulakan docker. Sebaik sahaja anda melakukannya, buka terminal anda dan jalankan arahan ini:
go mod init bookstore
Selepas itu anda perlu menjalankan bekas dengan arahan ini:
go get github.com/google/uuid \
github.com/gorilla/mux \
github.com/joho/godotenv \
github.com/lib/pq \
github.com/permitio/permit-golang \
golang.org/x/crypto
Ganti bahagian yang tertera
Untuk membina aplikasi, beginilah struktur projek kami:
docker pull permitio/pdp-v2:latest
Mari kita tambahkan Kunci API kita dahulu di dalam fail .env. Buat satu, dan kemudian kunci API permit anda seperti itu:
docker run -it -p 7766:7000 --env PDP_DEBUG=True --env PDP_API_KEY=<YOUR_API_KEY> permitio/pdp-v2:latest
Buat folder bernama config. Di dalamnya, buat fail bernama config.go. Tambahkan kod berikut:
Bookstore ├── config │ └── config.go │ ├── handlers │ └── handlers.go │ ├── middleware │ └── middleware.go │ ├── models │ └── models.go │ ├── templates │ ├── add.html │ ├── books.html │ ├── index.html │ ├── layout.html │ ├── login.html │ └── update.html │ ├── main.go └── .env
Ini hanyalah kami yang menyediakan konfigurasi untuk menyambung ke pangkalan data PostgreSQL.
Seterusnya, buat folder yang dipanggil pengendali, dan di dalamnya, buat fail bernama handler.go. Di dalamnya, tambahkan kod berikut:
export PERMIT_API_KEY=”your_api_key”
Selain mengimport pakej, perkara yang kami cuba lakukan di sini ialah mencipta struktur yang memegang sambungan pangkalan data dan permit.io. Kami juga menyediakan fungsi permulaan yang menyediakan Permit.io dengan PDP tempatan.
Sejurus selepas NewHandlers menambah ini dalam:
package config
import (
"database/sql"
"fmt"
_ "github.com/lib/pq"
)
type Config struct {
DB *sql.DB
Port string
DBConfig PostgresConfig
}
type PostgresConfig struct {
Host string
Port string
User string
Password string
DBName string
}
func NewConfig() *Config {
return &Config{
Port: "8080",
DBConfig: PostgresConfig{
Host: "localhost",
Port: "5432",
User: "bookstore_user",
Password: "your_password",
DBName: "bookstore_db",
},
}
}
func (c *Config) ConnectDB() error {
connStr := fmt.Sprintf("host=%s port=%s user=%s password=%s dbname=%s sslmode=disable",
c.DBConfig.Host,
c.DBConfig.Port,
c.DBConfig.User,
c.DBConfig.Password,
c.DBConfig.DBName,
)
db, err := sql.Open("postgres", connStr)
if err != nil {
return fmt.Errorf("error opening database: %v", err)
}
if err := db.Ping(); err != nil {
return fmt.Errorf("error connecting to database: %v", err)
}
c.DB = db
return nil
}
LoginHandler melakukan perkara berikut:
Langkah seterusnya ialah menambah pengendali buku untuk mengakses buku. Ia juga akan menggunakan permit.io untuk mengesahkan peranan pengguna. Tambahkan kod berikut sejurus selepas LoginHandler:
package handlers
import (
"bookstore/middleware"
"bookstore/models"
"context"
"database/sql"
"fmt"
"html/template"
"net/http"
"strings"
"time"
"github.com/google/uuid"
"github.com/permitio/permit-golang/pkg/config"
"github.com/permitio/permit-golang/pkg/enforcement"
permitModels "github.com/permitio/permit-golang/pkg/models"
"github.com/permitio/permit-golang/pkg/permit"
)
var tmpl = template.Must(template.ParseGlob("templates/*.html"))
func StringPtr(s string) *string {
return &s
}
type Handlers struct {
db *sql.DB
permitClient *permit.Client
}
func NewHandlers(db *sql.DB, apiKey string) *Handlers {
permitConfig := config.NewConfigBuilder(apiKey).
WithPdpUrl("http://localhost:7766").
Build()
permitClient := permit.NewPermit(permitConfig)
if permitClient == nil {
panic("Failed to initialize Permit.io client")
}
return &Handlers{
db: db,
permitClient: permitClient,
}
}
Pengurus Buku melakukan perkara berikut:
Seterusnya, anda memerlukan pengendali untuk menambah buku. Ia juga akan mengesahkan peranan pengguna melalui Permit.io untuk memastikan hanya pengguna yang diberi kuasa boleh menambah buku:
CREATE TABLE users ( id SERIAL PRIMARY KEY, username VARCHAR(255) NOT NULL, password_hash VARCHAR(255) NOT NULL, role VARCHAR(50) NOT NULL );
AddBookHandler melakukan perkara berikut:
Anda memerlukan dua lagi pengendali, satu untuk memadam dan satu lagi untuk mengemas kini. Tambahkan kod ini sejurus selepas fungsi AddBookHandler:
CREATE TABLE books ( id UUID PRIMARY KEY DEFAULT gen_random_uuid(), title VARCHAR(255) NOT NULL, author VARCHAR(255) NOT NULL, published_at DATE, created_at TIMESTAMPTZ DEFAULT now() );
DeleteBookHandler melakukan perkara berikut:
Sejurus selepas fungsi DeleteBookHandler, tambahkan yang berikut:
go mod init bookstore
Pengendali Kemas Kini melakukan perkara berikut:
Sepanjang kod, anda akan dapati bahawa sistem kebenaran dibina di sekitar rangka kerja kawalan akses berasaskan peranan Permit.io, yang menyediakan pengurusan kebenaran yang canggih.
Sistem ini juga membolehkan kawalan terperinci ke atas tindakan pengguna dan membenarkan tahap akses yang berbeza untuk melihat, mencipta, mengemas kini dan memadamkan sumber. Setiap operasi dalam aplikasi menjalani semakan kebenaran terperinci dan memastikan pengguna hanya boleh melakukan tindakan yang mereka dibenarkan.
Sekarang kita sudah selesai dengan pengendali. Cipta folder bernama middleware, dan di dalamnya, buat fail bernama middleware.go. Tambahkan kod berikut:
go get github.com/google/uuid \
github.com/gorilla/mux \
github.com/joho/godotenv \
github.com/lib/pq \
github.com/permitio/permit-golang \
golang.org/x/crypto
Pakej perisian tengah ini membantu menyediakan pencincangan dan pengesahan kata laluan yang selamat, bersama-sama dengan operasi CRUD untuk mengurus buku dalam aplikasi kedai buku. Ia menggunakan bcrypt untuk mencincang kata laluan untuk storan selamat dan mengesahkan cincang kata laluan semasa log masuk. Ia juga menghalang pendedahan data sensitif.
Fungsi LoginUser mengesahkan pengguna dengan membandingkan input mereka dengan cincang kata laluan yang disimpan dan mendapatkan semula profil pengguna penuh apabila log masuk berjaya, tidak termasuk cincang kata laluan untuk keselamatan tambahan.
Selain itu, operasi CRUD membolehkan anda membuat, mengemas kini, mendapatkan semula dan memadam rekod buku dalam pangkalan data, dengan kawalan akses untuk memastikan hanya pengguna yang diberi kuasa boleh mengubah suai atau memadamkan entri yang mereka cipta. Pakej ini juga termasuk fungsi GetUserRole untuk mendapatkan semula peranan pengguna, memudahkan kawalan akses berasaskan peranan.
Buat folder lain yang dipanggil model, dan di dalamnya, buat fail bernama models.go. Dan tambahkan yang berikut:
CREATE TABLE users ( id SERIAL PRIMARY KEY, username VARCHAR(255) NOT NULL, password_hash VARCHAR(255) NOT NULL, role VARCHAR(50) NOT NULL );
Pakej ini mentakrifkan beberapa model data untuk aplikasi kedai buku, termasuk struktur Pengguna, Buku dan Permintaan Masuk, bersama-sama dengan jenis NullUUID tersuai untuk mengendalikan UUID boleh null dalam pangkalan data.
Hampir selesai. Perkara seterusnya yang perlu anda lakukan ialah mencipta templat untuk projek anda. Anda perlu membuat templat untuk log masuk dan indeks, untuk menambah buku, melihat buku, memadamkan buku dan mengemas kini buku.
Buat folder yang dipanggil templat. Di sinilah templat html anda akan berada.
Untuk log masuk, buat fail yang dipanggil login.html, dan di dalamnya, tampal ini:
CREATE TABLE books ( id UUID PRIMARY KEY DEFAULT gen_random_uuid(), title VARCHAR(255) NOT NULL, author VARCHAR(255) NOT NULL, published_at DATE, created_at TIMESTAMPTZ DEFAULT now() );
Pakej utama ini berfungsi sebagai pintu masuk untuk aplikasi kedai buku. Ia menyediakan sambungan pangkalan data, konfigurasi persekitaran dan laluan HTTP untuk mengendalikan log masuk pengguna dan pengurusan buku.
Dalam fungsi utama, laluan didaftarkan menggunakan penghala Gorilla Mux. Fungsi handlers.NewHandlers memulakan pengendali dengan pangkalan data dan kunci API Permit.io. Ia membolehkan kefungsian seperti pengesahan pengguna (/log masuk) dan pengurusan buku (/books, /add, /delete, /update). Setiap laluan dipetakan kepada kaedah HTTP tertentu, mengatur titik akhir untuk tindakan yang berbeza.
Akhir sekali, pelayan bermula pada port 8080, mendengar permintaan masuk dan mengelog sebarang ralat yang berlaku. Persediaan ini memastikan konfigurasi titik akhir API berstruktur dan pengendalian selamat pembolehubah persekitaran.
Sekarang itu tentang segala-galanya! Mari mulakan aplikasi kami untuk melihat. hasilnya. Untuk memulakan pelayan, jalankan arahan ini:
go mod init bookstore
Lawati http://localhost:8080/login dalam penyemak imbas anda.
Mari kita mulakan dengan menguji hanya kebenaran pengguna_standard:
Anda akan melihat bahawa pengguna_standard dihadkan untuk melihat buku sahaja dan tidak boleh menambah, memadam atau mengemas kini buku.
Mari kita log masuk menggunakan admin_user untuk melihat apa yang berlaku:
Anda akan melihat bahawa pentadbir mempunyai kebenaran untuk melakukan apa sahaja! Begitulah Permit yang kukuh dan mudah digunakan!
Anda boleh menyemak sumber ini untuk mengetahui lebih lanjut tentang kebenaran Permit:
Dalam tutorial ini, kami membina apl pengurusan kedai buku ringkas untuk melaksanakan kawalan akses berasaskan peranan menggunakan Go, HTMX dan Permit.io. Keizinan adalah aspek asas keselamatan aplikasi, kerana ia memastikan pengguna hanya boleh mengakses perkara yang dibenarkan.
Melaksanakan model kawalan akses yang berkesan seperti RBAC atau ABAC ke dalam aplikasi anda bukan sahaja akan menjamin aplikasi anda tetapi juga meningkatkan kebolehskalaan dan pematuhannya.
Atas ialah kandungan terperinci Cara Menyediakan Keizinan dalam Sistem Pengurusan Kedai Buku dengan Go, HTMX dan Permit.io. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!
![[Web front-end] Permulaan pantas Node.js](https://img.php.cn/upload/course/000/000/067/662b5d34ba7c0227.png)
