To create a Golang application that connects to a PostgreSQL database and performs basic CRUD operations on a "users" table, follow these steps:

1. Install the necessary packages:
- First, you need to install the `pq` package which is a PostgreSQL driver for Go's `database/sql` package.
```bash
go get -u github.com/lib/pq
```

2. Create a new folder for your project and initialize it as a Go module:
```bash
mkdir go-postgres-crud
cd go-postgres-crud
go mod init example.com/go-postgres-crud
```

3. Create a `main.go` file in the root of your project folder.

4. Add the following code to `main.go`:

```go
package main

import (
	"database/sql"
	"fmt"
	"log"

	_ "github.com/lib/pq"
)

const (
	host     = "localhost"
	port     = 5432
	user     = "postgres"
	password = "your-password"
	dbname   = "your-db-name"
)

type User struct {
	ID    int
	Name  string
	Email string
	Age   int
}

func main() {
	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 {
		log.Fatal(err)
	}
	defer db.Close()

	err = db.Ping()
	if err != nil {
		log.Fatal(err)
	}

	fmt.Println("Successfully connected!")

	// Perform CRUD operations here
}
```
Replace `"your-password"` and `"your-db-name"` with your actual PostgreSQL password and database name.

5. Implement the CRUD functions:

Create a user:
```go
func createUser(db *sql.DB, user User) error {
	sqlStatement := `
	INSERT INTO users (name, email, age)
	VALUES ($1, $2, $3)
	RETURNING id`
	err := db.QueryRow(sqlStatement, user.Name, user.Email, user.Age).Scan(&user.ID)

	if err != nil {
		return err
	}

	fmt.Println("New record ID is:", user.ID)
	return nil
}
```

Read a user by ID:
```go
func getUserByID(db *sql.DB, id int) (*User, error) {
	sqlStatement := `SELECT id, name, email, age FROM users WHERE id=$1;`
	var user User
	row := db.QueryRow(sqlStatement, id)
	err := row.Scan(&user.ID, &user.Name, &user.Email, &user.Age)

	switch err {
	case sql.ErrNoRows:
		fmt.Println("No rows were returned!")
		return nil, err
	case nil:
		return &user, nil
	default:
		return nil, err
	}
}
```

Update a user by ID:
```go
func updateUserByID(db *sql.DB, id int, user User) error {
	sqlStatement := `
	UPDATE users
	SET name = $2, email = $3, age = $4
	WHERE id = $1;`

	res, err := db.Exec(sqlStatement, id, user.Name, user.Email, user.Age)
	if err != nil {
		return err
	}

	rowsAffected, err := res.RowsAffected()
	if err != nil {
		return err
	}

	fmt.Println("Number of records updated:", rowsAffected)
	return nil
}
```

Delete a user by ID:
```go
func deleteUserByID(db *sql.DB, id int) error {
	sqlStatement := `DELETE FROM users WHERE id = $1;`
	res, err := db.Exec(sqlStatement, id)
	if err != nil {
		return err
	}

	rowsAffected, err := res.RowsAffected()
	if err != nil {
		return err
	}

	fmt.Println("Number of records deleted:", rowsAffected)
	return nil
}
```

6. Use the CRUD functions in your `main` function:

```go
func main() {
	// ...

	// Create a user
	newUser := User{Name: "John Doe", Email: "john.doe@example.com", Age: 30}
	err = createUser(db, newUser)
	if err != nil {
		log.Fatal(err)
	}

	// Get a user by ID
	user, err := getUserByID(db, 1)
	if err != nil {
		log.Fatal(err)
	}
	fmt.Printf("User: %+v\n", user)

	// Update a user by ID
	updatedUser := User{Name: "Jane Doe", Email: "jane.doe@example.com", Age: 28}
	err = updateUserByID(db, 1, updatedUser)
	if err != nil {
		log.Fatal(err)
	}

	// Delete a user by ID
	err = deleteUserByID(db, 2)
	if err != nil {
		log.Fatal(err)
	}
}
```

7. Run your application:
```bash
go run main.go
```

This will connect to your PostgreSQL database and perform basic CRUD operations on the "users" table.

Make sure you have created the "users" table in your PostgreSQL database with the following schema:

```sql
CREATE TABLE users (
    id SERIAL PRIMARY KEY,
    name VARCHAR(100) NOT NULL,
    email VARCHAR(100) UNIQUE NOT NULL,
    age INTEGER NOT NULL
);
```
PostgreSQL 데이터베이스에 연결하고 "users" 테이블에서 기본 CRUD 작업을 수행하는 Golang 애플리케이션을 만들려면 다음 단계를 따르세요.

1. 필요한 패키지 설치:
- 먼저, Go의 `database/sql` 패키지를 위한 PostgreSQL 드라이버인 `pq` 패키지를 설치해야 합니다.
```bash
go get -u github.com/lib/pq
```

2. 프로젝트를 위한 새 폴더를 생성하고 Go 모듈로 초기화합니다:
```bash
mkdir go-postgres-crud
cd go-postgres-crud
go mod init example.com/go-postgres-crud
```

3. 프로젝트 폴더의 루트에 `main.go` 파일을 생성합니다.

4. `main.go`에 다음 코드를 추가합니다:

```go
package main

import (
	"database/sql"
	"fmt"
	"log"

	_ "github.com/lib/pq"
)

const (
	host     = "localhost"
	port     = 5432
	user     = "postgres"
	password = "your-password"
	dbname   = "your-db-name"
)

type User struct {
	ID    int
	Name  string
	Email string
	Age   int
}

func main() {
	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 {
		log.Fatal(err)
	}
	defer db.Close()

	err = db.Ping()
	if err != nil {
		log.Fatal(err)
	}

	fmt.Println("Successfully connected!")

	// Perform CRUD operations here
}
```
`"your-password"` 및 `"your-db-name"`을 실제 PostgreSQL 비밀번호 및 데이터베이스 이름으로 바꿉니다.

5. CRUD 함수를 구현합니다:

사용자를 만듭니다:
```go
func createUser(db *sql.DB, user User) error {
	sqlStatement := `
	INSERT INTO users (name, email, age)
	VALUES ($1, $2, $3)
	RETURNING id`
	err := db.QueryRow(sqlStatement, user.Name, user.Email, user.Age).Scan(&user.ID)

	if err != nil {
		return err
	}

	fmt.Println("New record ID is:", user.ID)
	return nil
}
```

ID로 사용자를 읽습니다:
```go
func getUserByID(db *sql.DB, id int) (*User, error) {
	sqlStatement := `SELECT id, name, email, age FROM users WHERE id=$1;`
	var user User
	row := db.QueryRow(sqlStatement, id)
	err := row.Scan(&user.ID, &user.Name, &user.Email, &user.Age)

	switch err {
	case sql.ErrNoRows:
		fmt.Println("No rows were returned!")
		return nil, err
	case nil:
		return &user, nil
	default:
		return nil, err
	}
}
```

ID로 사용자를 업데이트합니다:
```go
func updateUserByID(db *sql.DB, id int, user User) error {
	sqlStatement := `
	UPDATE users
	SET name = $2, email = $3, age = $4
	WHERE id = $1;`

	res, err := db.Exec(sqlStatement, id, user.Name, user.Email, user.Age)
	if err != nil {
		return err
	}

	rowsAffected, err := res.RowsAffected()
	if err != nil {
		return err
	}

	fmt.Println("Number of records updated:", rowsAffected)
	return nil
}
```

ID로 사용자를 삭제합니다:
```go
func deleteUserByID(db *sql.DB, id int) error {
	sqlStatement := `DELETE FROM users WHERE id = $1;`
	res, err := db.Exec(sqlStatement, id)
	if err != nil {
		return err
	}

	rowsAffected, err := res.RowsAffected()
	if err != nil {
		return err
	}

	fmt.Println("Number of records deleted:", rowsAffected)
	return nil
}
```

6. `main` 함수에서 CRUD 함수를 사용합니다:

```go
func main() {
	// ...

	// Create a user
	newUser := User{Name: "John Doe", Email: "john.doe@example.com", Age: 30}
	err = createUser(db, newUser)
	if err != nil {
		log.Fatal(err)
	}

	// Get a user by ID
	user, err := getUserByID(db, 1)
	if err != nil {
		log.Fatal(err)
	}
	fmt.Printf("User: %+v\n", user)

	// Update a user by ID
	updatedUser := User{Name: "Jane Doe", Email: "jane.doe@example.com", Age: 28}
	err = updateUserByID(db, 1, updatedUser)
	if err != nil {
		log.Fatal(err)
	}

	// Delete a user by ID
	err = deleteUserByID(db, 2)
	if err != nil {
		log.Fatal(err)
	}
}
```

7. 애플리케이션을 실행합니다:
```bash
go run main.go
```

이렇게 하면 PostgreSQL 데이터베이스에 연결하여 "users" 테이블에 대한 기본 CRUD 작업을 수행합니다.

다음 스키마를 사용하여 PostgreSQL 데이터베이스에 "users" 테이블을 생성했는지 확인합니다:

```sql
CREATE TABLE users (
    id SERIAL PRIMARY KEY,
    name VARCHAR(100) NOT NULL,
    email VARCHAR(100) UNIQUE NOT NULL,
    age INTEGER NOT NULL
);
```