# API 보호

**URL:** https://heroiclabs.com/docs/kr/nakama/guides/server-framework/guarding-apis/
**Summary:** 클라이언트 요청에 대해 원하는 유효성 검사를 수행하거나 게임 로직을 우회하려는 클라이언트 시도를 방지하는 데 유용한, 일부 또는 모든 Nakama API에 대한 클라이언트 액세스를 제한하거나 완전히 방지하는 방법을 보여주는 가이드.

---


# API 보호

클라이언트 요청에 대해 원하는 유효성 검사를 수행하거나 게임 로직을 우회하려는 클라이언트 시도를 방지하는 데 유용한, 일부 또는 모든 Nakama API에 대한 클라이언트 액세스를 제한하거나 완전히 방지하려는 이유는 많습니다.

Nakama에는 악의적인 클라이언트 작업으로부터 게임을 보호할 수 있는 다양한 방법이 제공됩니다:

- 서버에서 RPC 또는 후크로 게임 로직 구현
- 저장소 객체에 대한 [액세스 제어](../../../concepts/storage/permissions/) 설정. REST API를 통해 생성된 개체는 항상 인증된 사용자가 소유하며, 이에 따라 읽기 권한을 설정하여 다른 플레이어가 이 데이터에 대한 읽기 액세스 권한을 가지고 있는지 설정할 수 있습니다.
- 서버 간 호출은 [HTTP 키](../../../server-framework/introduction/#server-to-server)를 통해 보호할 수 있습니다.
- 클라이언트에서 직접 액세스할 수 없는 API를 비활성화하려면 [사전 후크를 사용](../../../server-framework/introduction/hooks/#before-hooks)합니다.

## 사전 후크 사용

API를 비활성화하려면 비활성화하려는 함수 호출에 [사전 후크를 등록](../../../server-framework/introduction/hooks/#before-hooks)하고 요청 입력을 반환하는 대신 `nil`을(를) 반환합니다. Nakama는 비활성화된 API 호출과 같은 모든 시나리오를 자동으로 처리합니다.

아래에 제공된 예시 구현에서 주석 처리된 모든 메시지 이름 및 API 호출은 클라이언트에서 계속 사용할 수 있는 반면 다른 모든 것은 비활성화됩니다:

{{< code type="server" >}}
```go
package metagame

import (
  "context"
  "database/sql"

  "github.com/heroiclabs/nakama-common/api"
  "github.com/heroiclabs/nakama-common/rtapi"
  "github.com/heroiclabs/nakama-common/runtime"
)

func registerGuard(initializer runtime.Initializer) error {
  rtMessages := []string{
    //"ChannelJoin",
    //"ChannelLeave",
    //"ChannelMessageSend",
    "ChannelMessageUpdate",
    "ChannelMessageRemove",
    "MatchCreate",
    //"MatchDataSend",
    //"MatchJoin",
    //"MatchLeave",
    "MatchmakerAdd",
    "MatchmakerRemove",
    "PartyCreate",
    "PartyCreate",
    "PartyJoin",
    "PartyLeave",
    "PartyPromote",
    "PartyAccept",
    "PartyRemove",
    "PartyClose",
    "PartyJoinRequestList",
    "PartyMatchmakerAdd",
    "PartyMatchmakerRemove",
    "PartyDataSend",
    //"Ping",
    //"Pong",
    //"Rpc",
    "StatusFollow",
    "StatusUnfollow",
    "StatusUpdate",
  }
  for _, rtMessage := range rtMessages {
    if err := initializer.RegisterBeforeRt(rtMessage, func(ctx context.Context, logger runtime.Logger, db *sql.DB, nk runtime.NakamaModule, envelope *rtapi.Envelope) (*rtapi.Envelope, error) {
      return nil, nil
    }); err != nil {
      return err
    }
  }

  if err := initializer.RegisterBeforeGetAccount(func(ctx context.Context, logger runtime.Logger, db *sql.DB, nk runtime.NakamaModule) error {
    return nil
  }); err != nil {
    return err
  }
  //if err := initializer.RegisterBeforeUpdateAccount(func(ctx context.Context, logger runtime.Logger, db *sql.DB, nk runtime.NakamaModule, in *api.UpdateAccountRequest) (*api.UpdateAccountRequest, error) {
  //	return nil, nil
  //}); err != nil {
  //	return err
  //}
  //if err := initializer.RegisterBeforeSessionRefresh(func(ctx context.Context, logger runtime.Logger, db *sql.DB, nk runtime.NakamaModule, in *api.SessionRefreshRequest) (*api.SessionRefreshRequest, error) {
  //	return nil, nil
  //}); err != nil {
  //	return err
  //}
  //if err := initializer.RegisterBeforeAuthenticateApple(func(ctx context.Context, logger runtime.Logger, db *sql.DB, nk runtime.NakamaModule, in *api.AuthenticateAppleRequest) (*api.AuthenticateAppleRequest, error) {
  //	return nil, nil
  //}); err != nil {
  //	return err
  //}
  if err := initializer.RegisterBeforeAuthenticateCustom(func(ctx context.Context, logger runtime.Logger, db *sql.DB, nk runtime.NakamaModule, in *api.AuthenticateCustomRequest) (*api.AuthenticateCustomRequest, error) {
    return nil, nil
  }); err != nil {
    return err
  }
  //if err := initializer.RegisterBeforeAuthenticateDevice(func(ctx context.Context, logger runtime.Logger, db *sql.DB, nk runtime.NakamaModule, in *api.AuthenticateDeviceRequest) (*api.AuthenticateDeviceRequest, error) {
  //	return nil, nil
  //}); err != nil {
  //	return err
  //}
  if err := initializer.RegisterBeforeAuthenticateEmail(func(ctx context.Context, logger runtime.Logger, db *sql.DB, nk runtime.NakamaModule, in *api.AuthenticateEmailRequest) (*api.AuthenticateEmailRequest, error) {
    return nil, nil
  }); err != nil {
    return err
  }
  //if err := initializer.RegisterBeforeAuthenticateFacebook(func(ctx context.Context, logger runtime.Logger, db *sql.DB, nk runtime.NakamaModule, in *api.AuthenticateFacebookRequest) (*api.AuthenticateFacebookRequest, error) {
  //	return nil, nil
  //}); err != nil {
  //	return err
  //}
  if err := initializer.RegisterBeforeAuthenticateFacebookInstantGame(func(ctx context.Context, logger runtime.Logger, db *sql.DB, nk runtime.NakamaModule, in *api.AuthenticateFacebookInstantGameRequest) (*api.AuthenticateFacebookInstantGameRequest, error) {
    return nil, nil
  }); err != nil {
    return err
  }
  //if err := initializer.RegisterBeforeAuthenticateGameCenter(func(ctx context.Context, logger runtime.Logger, db *sql.DB, nk runtime.NakamaModule, in *api.AuthenticateGameCenterRequest) (*api.AuthenticateGameCenterRequest, error) {
  //	return nil, nil
  //}); err != nil {
  //	return err
  //}
  //if err := initializer.RegisterBeforeAuthenticateGoogle(func(ctx context.Context, logger runtime.Logger, db *sql.DB, nk runtime.NakamaModule, in *api.AuthenticateGoogleRequest) (*api.AuthenticateGoogleRequest, error) {
  //	return nil, nil
  //}); err != nil {
  //	return err
  //}
  if err := initializer.RegisterBeforeAuthenticateSteam(func(ctx context.Context, logger runtime.Logger, db *sql.DB, nk runtime.NakamaModule, in *api.AuthenticateSteamRequest) (*api.AuthenticateSteamRequest, error) {
    return nil, nil
  }); err != nil {
    return err
  }
  //if err := initializer.RegisterBeforeListChannelMessages(func(ctx context.Context, logger runtime.Logger, db *sql.DB, nk runtime.NakamaModule, in *api.ListChannelMessagesRequest) (*api.ListChannelMessagesRequest, error) {
  //	return nil, nil
  //}); err != nil {
  //	return err
  //}
  if err := initializer.RegisterBeforeListFriends(func(ctx context.Context, logger runtime.Logger, db *sql.DB, nk runtime.NakamaModule, in *api.ListFriendsRequest) (*api.ListFriendsRequest, error) {
    return nil, nil
  }); err != nil {
    return err
  }
  if err := initializer.RegisterBeforeAddFriends(func(ctx context.Context, logger runtime.Logger, db *sql.DB, nk runtime.NakamaModule, in *api.AddFriendsRequest) (*api.AddFriendsRequest, error) {
    return nil, nil
  }); err != nil {
    return err
  }
  if err := initializer.RegisterBeforeDeleteFriends(func(ctx context.Context, logger runtime.Logger, db *sql.DB, nk runtime.NakamaModule, in *api.DeleteFriendsRequest) (*api.DeleteFriendsRequest, error) {
    return nil, nil
  }); err != nil {
    return err
  }
  if err := initializer.RegisterBeforeBlockFriends(func(ctx context.Context, logger runtime.Logger, db *sql.DB, nk runtime.NakamaModule, in *api.BlockFriendsRequest) (*api.BlockFriendsRequest, error) {
    return nil, nil
  }); err != nil {
    return err
  }
  if err := initializer.RegisterBeforeImportFacebookFriends(func(ctx context.Context, logger runtime.Logger, db *sql.DB, nk runtime.NakamaModule, in *api.ImportFacebookFriendsRequest) (*api.ImportFacebookFriendsRequest, error) {
    return nil, nil
  }); err != nil {
    return err
  }
  if err := initializer.RegisterBeforeCreateGroup(func(ctx context.Context, logger runtime.Logger, db *sql.DB, nk runtime.NakamaModule, in *api.CreateGroupRequest) (*api.CreateGroupRequest, error) {
    return nil, nil
  }); err != nil {
    return err
  }
  if err := initializer.RegisterBeforeUpdateGroup(func(ctx context.Context, logger runtime.Logger, db *sql.DB, nk runtime.NakamaModule, in *api.UpdateGroupRequest) (*api.UpdateGroupRequest, error) {
    return nil, nil
  }); err != nil {
    return err
  }
  if err := initializer.RegisterBeforeDeleteGroup(func(ctx context.Context, logger runtime.Logger, db *sql.DB, nk runtime.NakamaModule, in *api.DeleteGroupRequest) (*api.DeleteGroupRequest, error) {
    return nil, nil
  }); err != nil {
    return err
  }
  if err := initializer.RegisterBeforeJoinGroup(func(ctx context.Context, logger runtime.Logger, db *sql.DB, nk runtime.NakamaModule, in *api.JoinGroupRequest) (*api.JoinGroupRequest, error) {
    return nil, nil
  }); err != nil {
    return err
  }
  if err := initializer.RegisterBeforeLeaveGroup(func(ctx context.Context, logger runtime.Logger, db *sql.DB, nk runtime.NakamaModule, in *api.LeaveGroupRequest) (*api.LeaveGroupRequest, error) {
    return nil, nil
  }); err != nil {
    return err
  }
  // if err := initializer.RegisterBeforeAddGroupUsers(func(ctx context.Context, logger runtime.Logger, db *sql.DB, nk runtime.NakamaModule, in *api.AddGroupUsersRequest) (*api.AddGroupUsersRequest, error) {
  // 	return nil, nil
  // }); err != nil {
  // 	return err
  // }
  if err := initializer.RegisterBeforeBanGroupUsers(func(ctx context.Context, logger runtime.Logger, db *sql.DB, nk runtime.NakamaModule, in *api.BanGroupUsersRequest) (*api.BanGroupUsersRequest, error) {
    return nil, nil
  }); err != nil {
    return err
  }
  // if err := initializer.RegisterBeforeKickGroupUsers(func(ctx context.Context, logger runtime.Logger, db *sql.DB, nk runtime.NakamaModule, in *api.KickGroupUsersRequest) (*api.KickGroupUsersRequest, error) {
  // 	return nil, nil
  // }); err != nil {
  // 	return err
  // }
  // if err := initializer.RegisterBeforePromoteGroupUsers(func(ctx context.Context, logger runtime.Logger, db *sql.DB, nk runtime.NakamaModule, in *api.PromoteGroupUsersRequest) (*api.PromoteGroupUsersRequest, error) {
  // 	return nil, nil
  // }); err != nil {
  // 	return err
  // }
  // if err := initializer.RegisterBeforeDemoteGroupUsers(func(ctx context.Context, logger runtime.Logger, db *sql.DB, nk runtime.NakamaModule, in *api.DemoteGroupUsersRequest) (*api.DemoteGroupUsersRequest, error) {
  // 	return nil, nil
  // }); err != nil {
  // 	return err
  // }
  // if err := initializer.RegisterBeforeListGroupUsers(func(ctx context.Context, logger runtime.Logger, db *sql.DB, nk runtime.NakamaModule, in *api.ListGroupUsersRequest) (*api.ListGroupUsersRequest, error) {
  // 	return nil, nil
  // }); err != nil {
  // 	return err
  // }
  // if err := initializer.RegisterBeforeListUserGroups(func(ctx context.Context, logger runtime.Logger, db *sql.DB, nk runtime.NakamaModule, in *api.ListUserGroupsRequest) (*api.ListUserGroupsRequest, error) {
  // 	return nil, nil
  // }); err != nil {
  // 	return err
  // }
  // if err := initializer.RegisterBeforeListGroups(func(ctx context.Context, logger runtime.Logger, db *sql.DB, nk runtime.NakamaModule, in *api.ListGroupsRequest) (*api.ListGroupsRequest, error) {
  // 	return nil, nil
  // }); err != nil {
  // 	return err
  // }
  if err := initializer.RegisterBeforeDeleteLeaderboardRecord(func(ctx context.Context, logger runtime.Logger, db *sql.DB, nk runtime.NakamaModule, in *api.DeleteLeaderboardRecordRequest) (*api.DeleteLeaderboardRecordRequest, error) {
    return nil, nil
  }); err != nil {
    return err
  }
  if err := initializer.RegisterBeforeListLeaderboardRecords(func(ctx context.Context, logger runtime.Logger, db *sql.DB, nk runtime.NakamaModule, in *api.ListLeaderboardRecordsRequest) (*api.ListLeaderboardRecordsRequest, error) {
    return nil, nil
  }); err != nil {
    return err
  }
  if err := initializer.RegisterBeforeWriteLeaderboardRecord(func(ctx context.Context, logger runtime.Logger, db *sql.DB, nk runtime.NakamaModule, in *api.WriteLeaderboardRecordRequest) (*api.WriteLeaderboardRecordRequest, error) {
    return nil, nil
  }); err != nil {
    return err
  }
  if err := initializer.RegisterBeforeListLeaderboardRecordsAroundOwner(func(ctx context.Context, logger runtime.Logger, db *sql.DB, nk runtime.NakamaModule, in *api.ListLeaderboardRecordsAroundOwnerRequest) (*api.ListLeaderboardRecordsAroundOwnerRequest, error) {
    return nil, nil
  }); err != nil {
    return err
  }
  //if err := initializer.RegisterBeforeLinkApple(func(ctx context.Context, logger runtime.Logger, db *sql.DB, nk runtime.NakamaModule, in *api.AccountApple) (*api.AccountApple, error) {
  //	return nil, nil
  //}); err != nil {
  //	return err
  //}
  if err := initializer.RegisterBeforeLinkCustom(func(ctx context.Context, logger runtime.Logger, db *sql.DB, nk runtime.NakamaModule, in *api.AccountCustom) (*api.AccountCustom, error) {
    return nil, nil
  }); err != nil {
    return err
  }
  //if err := initializer.RegisterBeforeLinkDevice(func(ctx context.Context, logger runtime.Logger, db *sql.DB, nk runtime.NakamaModule, in *api.AccountDevice) (*api.AccountDevice, error) {
  //	return nil, nil
  //}); err != nil {
  //	return err
  //}
  if err := initializer.RegisterBeforeLinkEmail(func(ctx context.Context, logger runtime.Logger, db *sql.DB, nk runtime.NakamaModule, in *api.AccountEmail) (*api.AccountEmail, error) {
    return nil, nil
  }); err != nil {
    return err
  }
  //if err := initializer.RegisterBeforeLinkFacebook(func(ctx context.Context, logger runtime.Logger, db *sql.DB, nk runtime.NakamaModule, in *api.LinkFacebookRequest) (*api.LinkFacebookRequest, error) {
  //	return nil, nil
  //}); err != nil {
  //	return err
  //}
  if err := initializer.RegisterBeforeLinkFacebookInstantGame(func(ctx context.Context, logger runtime.Logger, db *sql.DB, nk runtime.NakamaModule, in *api.AccountFacebookInstantGame) (*api.AccountFacebookInstantGame, error) {
    return nil, nil
  }); err != nil {
    return err
  }
  //if err := initializer.RegisterBeforeLinkGameCenter(func(ctx context.Context, logger runtime.Logger, db *sql.DB, nk runtime.NakamaModule, in *api.AccountGameCenter) (*api.AccountGameCenter, error) {
  //	return nil, nil
  //}); err != nil {
  //	return err
  //}
  //if err := initializer.RegisterBeforeLinkGoogle(func(ctx context.Context, logger runtime.Logger, db *sql.DB, nk runtime.NakamaModule, in *api.AccountGoogle) (*api.AccountGoogle, error) {
  //	return nil, nil
  //}); err != nil {
  //	return err
  //}
  if err := initializer.RegisterBeforeLinkSteam(func(ctx context.Context, logger runtime.Logger, db *sql.DB, nk runtime.NakamaModule, in *api.LinkSteamRequest) (*api.LinkSteamRequest, error) {
    return nil, nil
  }); err != nil {
    return err
  }
  if err := initializer.RegisterBeforeListMatches(func(ctx context.Context, logger runtime.Logger, db *sql.DB, nk runtime.NakamaModule, in *api.ListMatchesRequest) (*api.ListMatchesRequest, error) {
    return nil, nil
  }); err != nil {
    return err
  }
  //if err := initializer.RegisterBeforeListNotifications(func(ctx context.Context, logger runtime.Logger, db *sql.DB, nk runtime.NakamaModule, in *api.ListNotificationsRequest) (*api.ListNotificationsRequest, error) {
  //	return nil, nil
  //}); err != nil {
  //	return err
  //}
  // if err := initializer.RegisterBeforeDeleteNotification(func(ctx context.Context, logger runtime.Logger, db *sql.DB, nk runtime.NakamaModule, in *api.DeleteNotificationsRequest) (*api.DeleteNotificationsRequest, error) {
  // 	return nil, nil
  // }); err != nil {
  // 	return err
  // }
  if err := initializer.RegisterBeforeListStorageObjects(func(ctx context.Context, logger runtime.Logger, db *sql.DB, nk runtime.NakamaModule, in *api.ListStorageObjectsRequest) (*api.ListStorageObjectsRequest, error) {
    return nil, nil
  }); err != nil {
    return err
  }
  if err := initializer.RegisterBeforeReadStorageObjects(func(ctx context.Context, logger runtime.Logger, db *sql.DB, nk runtime.NakamaModule, in *api.ReadStorageObjectsRequest) (*api.ReadStorageObjectsRequest, error) {
    return nil, nil
  }); err != nil {
    return err
  }
  if err := initializer.RegisterBeforeWriteStorageObjects(func(ctx context.Context, logger runtime.Logger, db *sql.DB, nk runtime.NakamaModule, in *api.WriteStorageObjectsRequest) (*api.WriteStorageObjectsRequest, error) {
    return nil, nil
  }); err != nil {
    return err
  }
  if err := initializer.RegisterBeforeDeleteStorageObjects(func(ctx context.Context, logger runtime.Logger, db *sql.DB, nk runtime.NakamaModule, in *api.DeleteStorageObjectsRequest) (*api.DeleteStorageObjectsRequest, error) {
    return nil, nil
  }); err != nil {
    return err
  }
  if err := initializer.RegisterBeforeJoinTournament(func(ctx context.Context, logger runtime.Logger, db *sql.DB, nk runtime.NakamaModule, in *api.JoinTournamentRequest) (*api.JoinTournamentRequest, error) {
    return nil, nil
  }); err != nil {
    return err
  }
  if err := initializer.RegisterBeforeListTournamentRecords(func(ctx context.Context, logger runtime.Logger, db *sql.DB, nk runtime.NakamaModule, in *api.ListTournamentRecordsRequest) (*api.ListTournamentRecordsRequest, error) {
    return nil, nil
  }); err != nil {
    return err
  }
  if err := initializer.RegisterBeforeListTournaments(func(ctx context.Context, logger runtime.Logger, db *sql.DB, nk runtime.NakamaModule, in *api.ListTournamentsRequest) (*api.ListTournamentsRequest, error) {
    return nil, nil
  }); err != nil {
    return err
  }
  if err := initializer.RegisterBeforeWriteTournamentRecord(func(ctx context.Context, logger runtime.Logger, db *sql.DB, nk runtime.NakamaModule, in *api.WriteTournamentRecordRequest) (*api.WriteTournamentRecordRequest, error) {
    return nil, nil
  }); err != nil {
    return err
  }
  if err := initializer.RegisterBeforeListTournamentRecordsAroundOwner(func(ctx context.Context, logger runtime.Logger, db *sql.DB, nk runtime.NakamaModule, in *api.ListTournamentRecordsAroundOwnerRequest) (*api.ListTournamentRecordsAroundOwnerRequest, error) {
    return nil, nil
  }); err != nil {
    return err
  }
  //if err := initializer.RegisterBeforeUnlinkApple(func(ctx context.Context, logger runtime.Logger, db *sql.DB, nk runtime.NakamaModule, in *api.AccountApple) (*api.AccountApple, error) {
  //	return nil, nil
  //}); err != nil {
  //	return err
  //}
  if err := initializer.RegisterBeforeUnlinkCustom(func(ctx context.Context, logger runtime.Logger, db *sql.DB, nk runtime.NakamaModule, in *api.AccountCustom) (*api.AccountCustom, error) {
    return nil, nil
  }); err != nil {
    return err
  }
  //if err := initializer.RegisterBeforeUnlinkDevice(func(ctx context.Context, logger runtime.Logger, db *sql.DB, nk runtime.NakamaModule, in *api.AccountDevice) (*api.AccountDevice, error) {
  //	return nil, nil
  //}); err != nil {
  //	return err
  //}
  if err := initializer.RegisterBeforeUnlinkEmail(func(ctx context.Context, logger runtime.Logger, db *sql.DB, nk runtime.NakamaModule, in *api.AccountEmail) (*api.AccountEmail, error) {
    return nil, nil
  }); err != nil {
    return err
  }
  //if err := initializer.RegisterBeforeUnlinkFacebook(func(ctx context.Context, logger runtime.Logger, db *sql.DB, nk runtime.NakamaModule, in *api.AccountFacebook) (*api.AccountFacebook, error) {
  //	return nil, nil
  //}); err != nil {
  //	return err
  //}
  if err := initializer.RegisterBeforeUnlinkFacebookInstantGame(func(ctx context.Context, logger runtime.Logger, db *sql.DB, nk runtime.NakamaModule, in *api.AccountFacebookInstantGame) (*api.AccountFacebookInstantGame, error) {
    return nil, nil
  }); err != nil {
    return err
  }
  if err := initializer.RegisterBeforeUnlinkGameCenter(func(ctx context.Context, logger runtime.Logger, db *sql.DB, nk runtime.NakamaModule, in *api.AccountGameCenter) (*api.AccountGameCenter, error) {
    return nil, nil
  }); err != nil {
    return err
  }
  if err := initializer.RegisterBeforeUnlinkGoogle(func(ctx context.Context, logger runtime.Logger, db *sql.DB, nk runtime.NakamaModule, in *api.AccountGoogle) (*api.AccountGoogle, error) {
    return nil, nil
  }); err != nil {
    return err
  }
  if err := initializer.RegisterBeforeUnlinkSteam(func(ctx context.Context, logger runtime.Logger, db *sql.DB, nk runtime.NakamaModule, in *api.AccountSteam) (*api.AccountSteam, error) {
    return nil, nil
  }); err != nil {
    return err
  }
  if err := initializer.RegisterBeforeGetUsers(func(ctx context.Context, logger runtime.Logger, db *sql.DB, nk runtime.NakamaModule, in *api.GetUsersRequest) (*api.GetUsersRequest, error) {
    return nil, nil
  }); err != nil {
    return err
  }

  return nil
}
```
{{< / code >}}

{{< code type="server" >}}
```typescript
let InitModule: nkruntime.InitModule = function (ctx: nkruntime.Context, logger: nkruntime.Logger, nk: nkruntime.Nakama, initializer: nkruntime.Initializer) {
  // initializer.registerRtBefore("ChannelJoin", guardFunction);
  // initializer.registerRtBefore("ChannelLeave", guardFunction);
  // initializer.registerRtBefore("ChannelMessageSend", guardFunction);
  initializer.registerRtBefore("ChannelMessageUpdate", guardFunction);
  initializer.registerRtBefore("ChannelMessageRemove", guardFunction);
  initializer.registerRtBefore("MatchCreate", guardFunction);
  // initializer.registerRtBefore("MatchDataSend", guardFunction);
  // initializer.registerRtBefore("MatchJoin", guardFunction);
  // initializer.registerRtBefore("MatchLeave", guardFunction);
  initializer.registerRtBefore("MatchmakerAdd", guardFunction);
  initializer.registerRtBefore("MatchmakerRemove", guardFunction);
  // initializer.registerRtBefore("Ping", guardFunction);
  // initializer.registerRtBefore("Pong", guardFunction);
  initializer.registerRtBefore("StatusFollow", guardFunction);
  initializer.registerRtBefore("StatusUnfollow", guardFunction);
  initializer.registerRtBefore("StatusUpdate", guardFunction);
  // initializer.registerBeforeUpdateAccount(guardFunction);
  // initializer.registerBeforeAuthenticateApple(guardFunction);
  initializer.registerBeforeAuthenticateCustom(guardFunction);
  // initializer.registerBeforeAuthenticateDevice(guardFunction);
  initializer.registerBeforeAuthenticateEmail(guardFunction);
  // initializer.registerBeforeAuthenticateFacebook(guardFunction);
  initializer.registerBeforeAuthenticateFacebookInstantGame(guardFunction);
  // initializer.registerBeforeAuthenticateGameCenter(guardFunction);
  // initializer.registerBeforeAuthenticateGoogle(guardFunction);
  initializer.registerBeforeAuthenticateSteam(guardFunction);
  // initializer.registerBeforeListChannelMessages(guardFunction);
  initializer.registerBeforeListFriends(guardFunction);
  initializer.registerBeforeAddFriends(guardFunction);
  initializer.registerBeforeDeleteFriends(guardFunction);
  initializer.registerBeforeBlockFriends(guardFunction);
  initializer.registerBeforeImportFacebookFriends(guardFunction);
  initializer.registerBeforeCreateGroup(guardFunction);
  initializer.registerBeforeUpdateGroup(guardFunction);
  initializer.registerBeforeDeleteGroup(guardFunction);
  initializer.registerBeforeJoinGroup(guardFunction);
  initializer.registerBeforeLeaveGroup(guardFunction);
  // initializer.registerBeforeAddGroupUsers(guardFunction);
  initializer.registerBeforeBanGroupUsers(guardFunction);
  // initializer.registerBeforeKickGroupUsers(guardFunction);
  // initializer.registerBeforePromoteGroupUsers(guardFunction);
  // initializer.registerBeforeDemoteGroupUsers(guardFunction);
  // initializer.registerBeforeListGroupUsers(guardFunction);
  // initializer.registerBeforeListUserGroups(guardFunction);
  // initializer.registerBeforeListGroups(guardFunction);
  initializer.registerBeforeDeleteLeaderboardRecord(guardFunction);
  initializer.registerBeforeListLeaderboardRecords(guardFunction);
  initializer.registerBeforeWriteLeaderboardRecord(guardFunction);
  initializer.registerBeforeListLeaderboardRecordsAroundOwner(guardFunction);
  // initializer.registerBeforeLinkApple(guardFunction);
  initializer.registerBeforeLinkCustom(guardFunction);
  // initializer.registerBeforeLinkDevice(guardFunction);
  initializer.registerBeforeLinkEmail(guardFunction);
  // initializer.registerBeforeLinkFacebook(guardFunction);
  initializer.registerBeforeLinkFacebookInstantGame(guardFunction);
  // initializer.registerBeforeLinkGameCenter(guardFunction);
  // initializer.registerBeforeLinkGoogle(guardFunction);
  initializer.registerBeforeLinkSteam(guardFunction);
  // initializer.registerBeforeListNotifications(guardFunction);
  // initializer.registerBeforeDeleteNotifications(guardFunction);
  initializer.registerBeforeListStorageObjects(guardFunction);
  initializer.registerBeforeReadStorageObjects(guardFunction);
  initializer.registerBeforeWriteStorageObjects(guardFunction);
  initializer.registerBeforeDeleteStorageObjects(guardFunction);
  initializer.registerBeforeJoinTournament(guardFunction);
  initializer.registerBeforeListTournamentRecords(guardFunction);
  initializer.registerBeforeListTournaments(guardFunction);
  initializer.registerBeforeWriteTournamentRecord(guardFunction);
  initializer.registerBeforeListTournamentRecordsAroundOwner(guardFunction);
  // initializer.registerBeforeUnlinkApple(guardFunction);
  initializer.registerBeforeUnlinkCustom(guardFunction);
  // initializer.registerBeforeUnlinkDevice(guardFunction);
  initializer.registerBeforeUnlinkEmail(guardFunction);
  // initializer.registerBeforeUnlinkFacebook(guardFunction);
  initializer.registerBeforeUnlinkFacebookInstantGame(guardFunction);
  initializer.registerBeforeUnlinkGameCenter(guardFunction);
  initializer.registerBeforeUnlinkSteam(guardFunction);
  initializer.registerBeforeGetUsers(guardFunction);
}

const guardFunction = function() {
  return null;
};

// Reference InitModule to avoid it getting removed on build
!InitModule && InitModule.bind(null);
```
{{< / code >}}

{{< missing type="server" lang="lua" / >}}

{{< note "important" >}}
TypeScript 서버 런타임에서 `registerBeforeGetAccount` 함수에 대해 보호하기 위해 `null`을(를) 반환할 수 없습니다. TypeScript에서 이 함수를 보호해야 하는 경우 대신 오류를 발생시킬 수 있습니다. 예: `throw new Error("Function disabled")`. 이 경우 Nakama에 오류 로그가 생성됩니다.
{{< / note >}}