To create a RESTful API for managing Todo items in Go, we'll use the following packages:

1. `net/http` - to handle HTTP requests and responses
2. `github.com/gorilla/mux` - for URL routing
3. `github.com/mattn/go-sqlite3` - SQLite driver for database operations

First, let's set up our project structure:

```
todo-api/
  ├── main.go
  ├── model/
  │   └── todo.go
  ├── handler/
  │   └── todo_handler.go
  └── db/
      └── sqlite.go
```

Now, let's start by implementing the SQLite database connection and CRUD operations.

**db/sqlite.go**

```go
package db

import (
	"database/sql"
	_ "github.com/mattn/go-sqlite3"
)

func InitDB() (*sql.DB, error) {
	db, err := sql.Open("sqlite3", "./todos.db")
	if err != nil {
		return nil, err
	}

	createTableQuery := `
	CREATE TABLE IF NOT EXISTS todos (
		id INTEGER PRIMARY KEY AUTOINCREMENT,
		title TEXT NOT NULL,
		completed BOOLEAN DEFAULT false
	);
	`

	_, err = db.Exec(createTableQuery)
	if err != nil {
		return nil, err
	}

	return db, nil
}
```

Next, let's define the Todo model.

**model/todo.go**

```go
package model

type Todo struct {
	ID        int    `json:"id"`
	Title     string `json:"title"`
	Completed bool   `json:"completed"`
}
```

Now, let's implement the handlers for our Todo API.

**handler/todo_handler.go**

```go
package handler

import (
	"encoding/json"
	"net/http"
	"strconv"

	"github.com/gorilla/mux"
	"github.com/yourusername/todo-api/db"
	"github.com/yourusername/todo-api/model"
)

func CreateTodo(w http.ResponseWriter, r *http.Request) {
	var todo model.Todo
	err := json.NewDecoder(r.Body).Decode(&todo)
	if err != nil {
		http.Error(w, err.Error(), http.StatusBadRequest)
		return
	}

	query := "INSERT INTO todos (title) VALUES (?)"
	result, err := db.DB.Exec(query, todo.Title)
	if err != nil {
		http.Error(w, err.Error(), http.StatusInternalServerError)
		return
	}

	id, _ := result.LastInsertId()
	todo.ID = int(id)
	w.Header().Set("Content-Type", "application/json")
	json.NewEncoder(w).Encode(todo)
}

// ... Implement other handlers for updating, deleting, and listing todos
```

Finally, let's set up the main.go file to start our server.

**main.go**

```go
package main

import (
	"log"
	"net/http"

	"github.com/gorilla/mux"
	"github.com/yourusername/todo-api/db"
	"github.com/yourusername/todo-api/handler"
)

func main() {
	r := mux.NewRouter()

	// Initialize SQLite database
	database, err := db.InitDB()
	if err != nil {
		log.Fatal(err)
	}
	db.DB = database
	defer db.DB.Close()

	// Set up routes
	r.HandleFunc("/todos", handler.CreateTodo).Methods("POST")
	r.HandleFunc("/todos/{id}", handler.UpdateTodo).Methods("PUT")
	r.HandleFunc("/todos/{id}", handler.DeleteTodo).Methods("DELETE")
	r.HandleFunc("/todos", handler.ListTodos).Methods("GET")

	// Start server
	log.Println("Starting server on :8080...")
	log.Fatal(http.ListenAndServe(":8080", r))
}
```

Now you can build and run your Todo API server:

```sh
$ go build && ./todo-api
```

Your RESTful API for managing Todo items should now be running on `http://localhost:8080`. You can test the endpoints using a tool like Postman or curl.
Go에서 할 일 항목을 관리하기 위한 RESTful API를 만들기 위해 다음 패키지를 사용합니다.

1. `net/http` - HTTP 요청과 응답을 처리하기 위해
2. `github.com/gorilla/mux` - URL 라우팅용
3. `github.com/mattn/go-sqlite3` - 데이터베이스 작업을 위한 SQLite 드라이버

먼저 프로젝트 구조를 설정해 봅시다:

```
todo-api/
  ├── main.go
  ├── model/
  │   └── todo.go
  ├── handler/
  │   └── todo_handler.go
  └── db/
      └── sqlite.go
```

이제 SQLite 데이터베이스 연결과 CRUD 작업을 구현하는 것부터 시작하겠습니다.

**db/sqlite.go**

```go
package db

import (
	"database/sql"
	_ "github.com/mattn/go-sqlite3"
)

func InitDB() (*sql.DB, error) {
	db, err := sql.Open("sqlite3", "./todos.db")
	if err != nil {
		return nil, err
	}

	createTableQuery := `
	CREATE TABLE IF NOT EXISTS todos (
		id INTEGER PRIMARY KEY AUTOINCREMENT,
		title TEXT NOT NULL,
		completed BOOLEAN DEFAULT false
	);
	`

	_, err = db.Exec(createTableQuery)
	if err != nil {
		return nil, err
	}

	return db, nil
}
```

다음으로 Todo 모델을 정의해 보겠습니다.

**model/todo.go**

```go
package model

type Todo struct {
	ID        int    `json:"id"`
	Title     string `json:"title"`
	Completed bool   `json:"completed"`
}
```

이제 Todo API의 핸들러를 구현해 보겠습니다.

**handler/todo_handler.go**

```go
package handler

import (
	"encoding/json"
	"net/http"
	"strconv"

	"github.com/gorilla/mux"
	"github.com/yourusername/todo-api/db"
	"github.com/yourusername/todo-api/model"
)

func CreateTodo(w http.ResponseWriter, r *http.Request) {
	var todo model.Todo
	err := json.NewDecoder(r.Body).Decode(&todo)
	if err != nil {
		http.Error(w, err.Error(), http.StatusBadRequest)
		return
	}

	query := "INSERT INTO todos (title) VALUES (?)"
	result, err := db.DB.Exec(query, todo.Title)
	if err != nil {
		http.Error(w, err.Error(), http.StatusInternalServerError)
		return
	}

	id, _ := result.LastInsertId()
	todo.ID = int(id)
	w.Header().Set("Content-Type", "application/json")
	json.NewEncoder(w).Encode(todo)
}

// ... 할 일 업데이트, 삭제, 나열을 위한 다른 핸들러 구현하기
```

마지막으로 서버를 시작하기 위해 main.go 파일을 설정해 보겠습니다.

**main.go**

```go
package main

import (
	"log"
	"net/http"

	"github.com/gorilla/mux"
	"github.com/yourusername/todo-api/db"
	"github.com/yourusername/todo-api/handler"
)

func main() {
	r := mux.NewRouter()

	// Initialize SQLite database
	database, err := db.InitDB()
	if err != nil {
		log.Fatal(err)
	}
	db.DB = database
	defer db.DB.Close()

	// Set up routes
	r.HandleFunc("/todos", handler.CreateTodo).Methods("POST")
	r.HandleFunc("/todos/{id}", handler.UpdateTodo).Methods("PUT")
	r.HandleFunc("/todos/{id}", handler.DeleteTodo).Methods("DELETE")
	r.HandleFunc("/todos", handler.ListTodos).Methods("GET")

	// Start server
	log.Println("Starting server on :8080...")
	log.Fatal(http.ListenAndServe(":8080", r))
}
```

이제 Todo API 서버를 빌드하고 실행할 수 있습니다:

```sh
$ go build && ./todo-api
```

이제 할 일 항목 관리를 위한 RESTful API가 `http://localhost:8080`에서 실행되고 있어야 합니다. Postman이나 curl과 같은 도구를 사용하여 엔드포인트를 테스트할 수 있습니다.