To develop a Golang web server that serves static files and provides RESTful API endpoints for CRUD operations on a PostgreSQL database, follow these steps:

1. Install the required packages

First, install Gorilla Mux and sqlx using `go get`:

```bash
go get -u github.com/gorilla/mux
go get -u github.com/jmoiron/sqlx
```

2. Import the necessary packages

In your main.go file, import the following packages:

```go
package main

import (
	"database/sql"
	"encoding/json"
	"fmt"
	"log"
	"net/http"

	"github.com/gorilla/mux"
	_ "github.com/lib/pq"
	"github.com/jmoiron/sqlx"
)
```

3. Set up the PostgreSQL connection

Replace `<username>`, `<password>`, `<dbname>` with your actual PostgreSQL credentials.

```go
const (
	host     = "localhost"
	port     = 5432
	user     = "<username>"
	password = "<password>"
	dbname   = "<dbname>"
)

func dbConnect() *sql.DB {
	psqlInfo := fmt.Sprintf("host=%s port=%d user=%s password=%s dbname=%s sslmode=disable", host, port, user, password, dbname)
	db, err := sql.Open("postgres", psqlInfo)
	if err != nil {
		panic(err)
	}
	err = db.Ping()
	if err != nil {
		panic(err)
	}
	return db
}
```

4. Define the data model

Create a struct to represent the records in your database table. For example, if you have a table called "users":

```go
type User struct {
	ID        int    `json:"id"`
	FirstName string `json:"first_name"`
	LastName  string `json:"last_name"`
	Email     string `json:"email"`
}
```

5. Implement the CRUD functions

Here are examples of create, read, update, and delete functions using sqlx:

```go
func createUser(w http.ResponseWriter, r *http.Request) {
	var user User
	json.NewDecoder(r.Body).Decode(&user)

	db := dbConnect()
	_, err := db.Exec("INSERT INTO users (first_name, last_name, email) VALUES ($1, $2, $3)", user.FirstName, user.LastName, user.Email)
	if err != nil {
		log.Fatal(err)
	}

	w.WriteHeader(http.StatusCreated)
	json.NewEncoder(w).Encode(user)
}

func getUsers(w http.ResponseWriter, r *http.Request) {
	db := dbConnect()

	rows, err := db.Queryx("SELECT * FROM users")
	if err != nil {
		log.Fatal(err)
	}

	var users []User
	for rows.Next() {
		var user User
		err = rows.StructScan(&user)
		if err != nil {
			log.Fatal(err)
		}
		users = append(users, user)
	}

	w.Header().Set("Content-Type", "application/json")
	json.NewEncoder(w).Encode(users)
}

func updateUser(w http.ResponseWriter, r *http.Request) {
	params := mux.Vars(r)
	id := params["id"]

	var user User
	json.NewDecoder(r.Body).Decode(&user)

	db := dbConnect()
	_, err := db.Exec("UPDATE users SET first_name=$1, last_name=$2, email=$3 WHERE id=$4", user.FirstName, user.LastName, user.Email, id)
	if err != nil {
		log.Fatal(err)
	}

	w.WriteHeader(http.StatusOK)
	json.NewEncoder(w).Encode(user)
}

func deleteUser(w http.ResponseWriter, r *http.Request) {
	params := mux.Vars(r)
	id := params["id"]

	db := dbConnect()
	_, err := db.Exec("DELETE FROM users WHERE id=$1", id)
	if err != nil {
		log.Fatal(err)
	}

	w.WriteHeader(http.StatusNoContent)
}
```

6. Set up the router and serve static files

```go
func main() {
	router := mux.NewRouter()

	// API endpoints
	router.HandleFunc("/api/users", createUser).Methods("POST")
	router.HandleFunc("/api/users", getUsers).Methods("GET")
	router.HandleFunc("/api/users/{id}", updateUser).Methods("PUT")
	router.HandleFunc("/api/users/{id}", deleteUser).Methods("DELETE")

	// Serve static files
	fs := http.FileServer(http.Dir("./static"))
	router.PathPrefix("/").Handler(fs)

	http.ListenAndServe(":8080", router)
}
```

Now you have a Golang web server that serves static files from the "./static" directory and provides RESTful API endpoints for CRUD operations on a PostgreSQL database using Gorilla Mux and sqlx.
정적 파일을 서비스하고 PostgreSQL 데이터베이스에서 CRUD 작업을 위한 RESTful API 엔드포인트를 제공하는 Golang 웹 서버를 개발하려면 다음 단계를 따르세요.

1. 필요한 패키지 설치

먼저, `go get`을 사용하여 Gorilla Mux 및 sqlx를 설치합니다:

```bash
go get -u github.com/gorilla/mux
go get -u github.com/jmoiron/sqlx
```

2. 필요한 패키지 가져오기

main.go 파일에서 다음 패키지를 가져옵니다:

```go
package main

import (
	"database/sql"
	"encoding/json"
	"fmt"
	"log"
	"net/http"

	"github.com/gorilla/mux"
	_ "github.com/lib/pq"
	"github.com/jmoiron/sqlx"
)
```

3. PostgreSQL 연결 설정

`<username>`, `<password>`, `<dbname>`을 실제 PostgreSQL 자격 증명으로 바꿉니다.

```go
const (
	host     = "localhost"
	port     = 5432
	user     = "<username>"
	password = "<password>"
	dbname   = "<dbname>"
)

func dbConnect() *sql.DB {
	psqlInfo := fmt.Sprintf("host=%s port=%d user=%s password=%s dbname=%s sslmode=disable", host, port, user, password, dbname)
	db, err := sql.Open("postgres", psqlInfo)
	if err != nil {
		panic(err)
	}
	err = db.Ping()
	if err != nil {
		panic(err)
	}
	return db
}
```

4. 데이터 모델 정의

데이터베이스 테이블의 레코드를 나타내는 구조체를 생성합니다. 예를 들어 "users"라는 테이블이 있다고 가정합니다:

```go
type User struct {
	ID        int    `json:"id"`
	FirstName string `json:"first_name"`
	LastName  string `json:"last_name"`
	Email     string `json:"email"`
}
```

5. CRUD 함수 구현

다음은 sqlx를 사용한 함수 생성, 읽기, 업데이트, 삭제의 예입니다:

```go
func createUser(w http.ResponseWriter, r *http.Request) {
	var user User
	json.NewDecoder(r.Body).Decode(&user)

	db := dbConnect()
	_, err := db.Exec("INSERT INTO users (first_name, last_name, email) VALUES ($1, $2, $3)", user.FirstName, user.LastName, user.Email)
	if err != nil {
		log.Fatal(err)
	}

	w.WriteHeader(http.StatusCreated)
	json.NewEncoder(w).Encode(user)
}

func getUsers(w http.ResponseWriter, r *http.Request) {
	db := dbConnect()

	rows, err := db.Queryx("SELECT * FROM users")
	if err != nil {
		log.Fatal(err)
	}

	var users []User
	for rows.Next() {
		var user User
		err = rows.StructScan(&user)
		if err != nil {
			log.Fatal(err)
		}
		users = append(users, user)
	}

	w.Header().Set("Content-Type", "application/json")
	json.NewEncoder(w).Encode(users)
}

func updateUser(w http.ResponseWriter, r *http.Request) {
	params := mux.Vars(r)
	id := params["id"]

	var user User
	json.NewDecoder(r.Body).Decode(&user)

	db := dbConnect()
	_, err := db.Exec("UPDATE users SET first_name=$1, last_name=$2, email=$3 WHERE id=$4", user.FirstName, user.LastName, user.Email, id)
	if err != nil {
		log.Fatal(err)
	}

	w.WriteHeader(http.StatusOK)
	json.NewEncoder(w).Encode(user)
}

func deleteUser(w http.ResponseWriter, r *http.Request) {
	params := mux.Vars(r)
	id := params["id"]

	db := dbConnect()
	_, err := db.Exec("DELETE FROM users WHERE id=$1", id)
	if err != nil {
		log.Fatal(err)
	}

	w.WriteHeader(http.StatusNoContent)
}
```

6. 라우터 설정 및 정적 파일 제공

```go
func main() {
	router := mux.NewRouter()

	// API endpoints
	router.HandleFunc("/api/users", createUser).Methods("POST")
	router.HandleFunc("/api/users", getUsers).Methods("GET")
	router.HandleFunc("/api/users/{id}", updateUser).Methods("PUT")
	router.HandleFunc("/api/users/{id}", deleteUser).Methods("DELETE")

	// Serve static files
	fs := http.FileServer(http.Dir("./static"))
	router.PathPrefix("/").Handler(fs)

	http.ListenAndServe(":8080", router)
}
```

이제 "./static" 디렉터리에서 정적 파일을 서비스하고, Gorilla Mux와 sqlx를 사용하여 PostgreSQL 데이터베이스에서 CRUD 작업을 위한 RESTful API 엔드포인트를 제공하는 Golang 웹 서버가 생겼습니다.