diff --git a/guides/source/ko/action_cable_overview.md b/guides/source/ko/action_cable_overview.md
index c250db2e0ca75..8753bb9fd62a4 100644
--- a/guides/source/ko/action_cable_overview.md
+++ b/guides/source/ko/action_cable_overview.md
@@ -1,58 +1,58 @@
**DO NOT READ THIS FILE ON GITHUB, GUIDES ARE PUBLISHED ON http://guides.rubyonrails.org.**
-Action Cable Overview
+액션케이블 시작하기
=====================
-In this guide, you will learn how Action Cable works and how to use WebSockets to
-incorporate real-time features into your Rails application.
+이 가이드에서는 액션케이블의 구조와 웹소켓을 레일스 애플리케이션에 도입하여
+실시간 기능을 구현하는 방법에 관해서 설명합니다.
-After reading this guide, you will know:
+이 가이드의 내용:
-* What Action Cable is and its integration backend and frontend
-* How to setup Action Cable
-* How to setup channels
-* Deployment and Architecture setup for running Action Cable
+* 액션케이블 개요, 백엔드와 프론트엔드 통합하기
+* 액션케이블 설정하기
+* 채널 설정하기
+* 액션케이블을 위한 배포 방법과 아키텍처 구성하기
--------------------------------------------------------------------------------
-Introduction
+들어가며
------------
-Action Cable seamlessly integrates
-[WebSockets](https://en.wikipedia.org/wiki/WebSocket) with the rest of your
-Rails application. It allows for real-time features to be written in Ruby in the
-same style and form as the rest of your Rails application, while still being
-performant and scalable. It's a full-stack offering that provides both a
-client-side JavaScript framework and a server-side Ruby framework. You have
-access to your full domain model written with Active Record or your ORM of
-choice.
+액션케이블은 [웹소켓](https://en.wikipedia.org/wiki/WebSocket)
+과 레일스의 다른 부분을 매끄럽게 통합합니다. 액션케이블을 통해
+일반 레일스 애플리케이션과 같은 형태와 스타일로 효율성과 확장성을
+계속해서 보장하는 동시에 실시간 기능을 루비로 구현할 수 있습니다.
+이는 클라이언트의 자바스크립트 프레임워크와 서버의 루비 프레임워크를
+동시에 제공하는풀스택 프레임워크입니다. 그러므로 액티브레코드 등의
+선택하고자 하는 ORM으로 작성된 모든 도메인 모델에 접근할 수
+있습니다.
-What is Pub/Sub
+Pub/Sub에 대하여
---------------
-[Pub/Sub](https://en.wikipedia.org/wiki/Publish%E2%80%93subscribe_pattern), or
-Publish-Subscribe, refers to a message queue paradigm whereby senders of
-information (publishers), send data to an abstract class of recipients
-(subscribers), without specifying individual recipients. Action Cable uses this
-approach to communicate between the server and many clients.
+[Pub/Sub](https://en.wikipedia.org/wiki/Publish%E2%80%93subscribe_pattern),
+또는 발행-구독은 정보를 보낸이(이하 '발행자')으로부터
+특정되지 않은 받는이(이하 '구독자')의 추상 클래스로
+정보를 보내는 메시지 큐 패러다임을 말합니다. 액션케이블은
+이러한 접근법으로 서버와 여러 클라이언트 간의 통신을 구현합니다.
-## Server-Side Components
+## 서버측 컴포넌트
-### Connections
+### 커넥션
-*Connections* form the foundation of the client-server relationship. For every
-WebSocket accepted by the server, a connection object is instantiated. This
-object becomes the parent of all the *channel subscriptions* that are created
-from there on. The connection itself does not deal with any specific application
-logic beyond authentication and authorization. The client of a WebSocket
-connection is called the connection *consumer*. An individual user will create
-one consumer-connection pair per browser tab, window, or device they have open.
+*커넥션(Connections)* 은 클라이언트와 서버 간의 관계의 기반이 됩니다.
+서버에서 웹소켓이 요청을 받을 때마다 커넥션 객체가 생성됩니다.
+이 객체는 앞으로 생성되는 모든 *채널 구독*의 부모가 됩니다.
+이 커넥션 자체는 인증이나 권한 이외의 어떠한 특정 애플리케이션
+로직도 다루지 않습니다. 웹소켓의 커넥션 클라이언트는 커넥션
+*소비자*라고도 불립니다. 사용자 개인이 여는 브라우저 탭, 윈도우,
+기기마다 소비자-커넥션 쌍을 하나씩 생성하게 됩니다.
-Connections are instances of `ApplicationCable::Connection`. In this class, you
-authorize the incoming connection, and proceed to establish it if the user can
-be identified.
+커넥션은 `ApplicationCable::Connection`의 객체 입니다.
+이 클래스에서는 들어온 커넥션 요청을 승인하고 인증된 사용자인 경우에
+커넥션을 성립시킵니다.
-#### Connection Setup
+#### 커넥션 설정
```ruby
# app/channels/application_cable/connection.rb
@@ -76,27 +76,27 @@ module ApplicationCable
end
```
-Here `identified_by` is a connection identifier that can be used to find the
-specific connection later. Note that anything marked as an identifier will automatically
-create a delegate by the same name on any channel instances created off the connection.
+`identified_by`는 커넥션 ID입니다. 이는 나중에 특정 커넥션을
+탐색하는 경우에도 사용될 수 있습니다. ID로 선언된 정보는 그 커넥션
+이외에도 생성된 모든 채널 인스턴스에 같은 이름이 자동으로 위임됩니다.
-This example relies on the fact that you will already have handled authentication of the user
-somewhere else in your application, and that a successful authentication sets a signed
-cookie with the user ID.
+예제는 이미 애플리케이션의 다른 곳 어딘가에서 사용자의 인증을
+다루고 있으며, 그것이 성공적으로 인증 되면 사용자 ID 로서 쿠키를
+내려주고 있다는 사실이 전제되어 있습니다.
-The cookie is then automatically sent to the connection instance when a new connection
-is attempted, and you use that to set the `current_user`. By identifying the connection
-by this same current user, you're also ensuring that you can later retrieve all open
-connections by a given user (and potentially disconnect them all if the user is deleted
-or unauthorized).
+이 쿠키는 새로운 커넥션이 시도되었을 때 자동적으로 커넥션 인스턴스로
+전송되고, 이를 통해 `current_user`를 설정하게 됩니다. 현재
+사용자와 같은 커넥션이라고 확인되면 그 사용자가 열어둔 모든 커넥션을
+가지게 되며, 사용자가 삭제되었거나 인증이 불가능한 경우에는 잠정적으로
+커넥션을 종료시킬 수도 있습니다.
-### Channels
+### 채널
-A *channel* encapsulates a logical unit of work, similar to what a controller does in a
-regular MVC setup. By default, Rails creates a parent `ApplicationCable::Channel` class
-for encapsulating shared logic between your channels.
+*채널(channel)*은 일반적인 MVC에서 컨트롤러가 하는 일과 마찬가지로, 작업을 논리적인
+단위로 캡슐화합니다. 레일스는 캡슐화하여 채널 간에 공유되는 로직을 위해
+기본적으로 `ApplicationCable::Channel`이라는 부모 클래스를 생성합니다.
-#### Parent Channel Setup
+#### 부모 채널 설정
```ruby
# app/channels/application_cable/channel.rb
@@ -106,8 +106,8 @@ module ApplicationCable
end
```
-Then you would create your own channel classes. For example, you could have a
-`ChatChannel` and an `AppearanceChannel`:
+이제 여러분이 사용할 Channel 클래스를 정의합니다. 예를 들어,
+`ChatChannel` 및 `AppearanceChannel`은 다음과 같이 정의할 수 있겠습니다:
```ruby
# app/channels/chat_channel.rb
@@ -119,32 +119,32 @@ class AppearanceChannel < ApplicationCable::Channel
end
```
-A consumer could then be subscribed to either or both of these channels.
+이로써 소비자는 이러한 채널을 구독할 수 있게 됩니다.
-#### Subscriptions
+#### 구독
-Consumers subscribe to channels, acting as *subscribers*. Their connection is
-called a *subscription*. Produced messages are then routed to these channel
-subscriptions based on an identifier sent by the cable consumer.
+소비자는 *구독자(subscribers)*처럼 행동하며 채널을 구독합니다.
+그리고 이러한 소비자의 커넥션을 *구독(subscription)*이라고 합니다.
+생성된 메시지들은 케이블 소비자가 전송한 ID를 기반으로 채널 구독에 라우팅 됩니다.
```ruby
# app/channels/chat_channel.rb
class ChatChannel < ApplicationCable::Channel
- # Called when the consumer has successfully
- # become a subscriber to this channel.
+ # 소비자가 성공적으로 이 채널의
+ # 구독자가 되었을 때 호출됨.
def subscribed
end
end
```
-## Client-Side Components
+## 클라이언트측 컴포넌트
-### Connections
+### 커넥션
-Consumers require an instance of the connection on their side. This can be
-established using the following JavaScript, which is generated by default by Rails:
+소비자 쪽에서도 커넥션 인스턴스가 필요합니다.
+이 커넥션은 레일스에 의해 기본으로 생성된 자바스크립트 코드를 통해 이뤄집니다:
-#### Connect Consumer
+#### 소비자 연결하기
```js
// app/assets/javascripts/cable.js
@@ -159,13 +159,13 @@ established using the following JavaScript, which is generated by default by Rai
}).call(this);
```
-This will ready a consumer that'll connect against `/cable` on your server by default.
-The connection won't be established until you've also specified at least one subscription
-you're interested in having.
+이로써 서버의 `/cable`에 대응해 접속하게 될 소비자가
+준비되었습니다. 단, 채널을 적어도 하나 이상 구독하기
+전에는 커넥션이 성립되지 않습니다.
-#### Subscriber
+#### 구독자
-A consumer becomes a subscriber by creating a subscription to a given channel:
+한 채널에 대해 구독을 생성하는 것으로 소비자는 구독자가 됩니다:
```coffeescript
# app/assets/javascripts/cable/subscriptions/chat.coffee
@@ -175,23 +175,23 @@ App.cable.subscriptions.create { channel: "ChatChannel", room: "Best Room" }
App.cable.subscriptions.create { channel: "AppearanceChannel" }
```
-While this creates the subscription, the functionality needed to respond to
-received data will be described later on.
+위와 같이 구독을 생성할 수 있으며, 수신한 데이터에
+응답하는 기능에 대해서는 나중에 설명하겠습니다.
-A consumer can act as a subscriber to a given channel any number of times. For
-example, a consumer could subscribe to multiple chat rooms at the same time:
+한 명의 소비자는 특정 채널에 대한 한 명의 구독자로서 몇 번이고 행동할 수 있습니다.
+예를 들어 소비자는 여러 채팅방을 동시에 구독할 수 있습니다:
```coffeescript
App.cable.subscriptions.create { channel: "ChatChannel", room: "1st Room" }
App.cable.subscriptions.create { channel: "ChatChannel", room: "2nd Room" }
```
-## Client-Server Interactions
+## 클라이언트-서버간 상호작용
-### Streams
+### 스트림
-*Streams* provide the mechanism by which channels route published content
-(broadcasts) to their subscribers.
+*스트림(Streams)*은 브로드캐스트나 발행하는 내용을
+구독자에게 라우팅하는 기능을 제공합니다.
```ruby
# app/channels/chat_channel.rb
@@ -202,9 +202,9 @@ class ChatChannel < ApplicationCable::Channel
end
```
-If you have a stream that is related to a model, then the broadcasting used
-can be generated from the model and channel. The following example would
-subscribe to a broadcasting like `comments:Z2lkOi8vVGVzdEFwcC9Qb3N0LzE`
+어떤 모델에 관련된 스트림을 생성하면, 그 모델과 채널로부터 브로드캐스트가
+생성됩니다. 다음 예제에서는 `comments:Z2lkOi8vVGVzdEFwcC9Qb3N0LzE`와
+같은 브로드캐스트를 구독합니다.
```ruby
class CommentsChannel < ApplicationCable::Channel
@@ -215,23 +215,23 @@ class CommentsChannel < ApplicationCable::Channel
end
```
-You can then broadcast to this channel like this:
+이것으로 이 채널에 다음과 같이 브로드캐스트를 할 수 있게 됩니다:
```ruby
CommentsChannel.broadcast_to(@post, @comment)
```
-### Broadcasting
+### 브로드캐스팅
-A *broadcasting* is a pub/sub link where anything transmitted by a publisher
-is routed directly to the channel subscribers who are streaming that named
-broadcasting. Each channel can be streaming zero or more broadcastings.
+*브로드캐스팅(broadcasting)*은 발행자가 채널의 구독자들에게
+어떤 것이든 전송할 수 있는 pub/sub 연결입니다. 각 채널은
+여러 개의 브로드캐스트를 스트리밍할 수 있습니다.
-Broadcastings are purely an online queue and time-dependent. If a consumer is
-not streaming (subscribed to a given channel), they'll not get the broadcast
-should they connect later.
+브로드캐스트는 순수한 온라인 큐이며, 시간에 의존합니다.
+스트리밍(한 채널에 대한 구독)하고 있지 않은 소비자는
+나중에 접속할 경우 브로드캐스트를 얻을 수 없습니다.
-Broadcasts are called elsewhere in your Rails application:
+브로드캐스트는 레일스 애플리케이션의 다른 장소에서도 호출할 수 있습니다:
```ruby
WebNotificationsChannel.broadcast_to(
@@ -241,24 +241,24 @@ WebNotificationsChannel.broadcast_to(
)
```
-The `WebNotificationsChannel.broadcast_to` call places a message in the current
-subscription adapter (by default `redis` for production and `async` for development and
-test environments)'s pubsub queue under a separate broadcasting name for each user.
-For a user with an ID of 1, the broadcasting name would be `web_notifications:1`.
+`WebNotificationsChannel.broadcast_to` 호출에서는 사용자마다 다른
+브로드캐스트 이름으로 현재 구독 어댑터(프로덕션 환경에서의 기본값은 `redis`이며,
+개발 환경과 테스트 환경에서는 `async`입니다) pubsub 큐에 메시지를 저장합니다.
+ID가 1인 사용자라면 브로드캐스트 이름은 `web_notifications:1`입니다.
-The channel has been instructed to stream everything that arrives at
-`web_notifications:1` directly to the client by invoking the `received`
-callback.
+received 콜백을 호출하면 이 채널은 `web_notifications:1`이
+수신하는 모든 것을 클라이언트에 직접
+스트리밍하게 됩니다.
-### Subscriptions
+### 구독
-When a consumer is subscribed to a channel, they act as a subscriber. This
-connection is called a subscription. Incoming messages are then routed to
-these channel subscriptions based on an identifier sent by the cable consumer.
+채널을 구독한 사용자는 구독자로서 행동합니다. 이 커넥션은
+구독이라 불립니다. 사용자가 전송한 ID에 기반하여
+구독 채널로 들어오는 메시지를 전송합니다.
```coffeescript
# app/assets/javascripts/cable/subscriptions/chat.coffee
-# Assumes you've already requested the right to send web notifications
+# 웹 알림을 보낼 수 있는 권한을 이미 요청했다고 가정
App.cable.subscriptions.create { channel: "ChatChannel", room: "Best Room" },
received: (data) ->
@appendLine(data)
@@ -276,10 +276,10 @@ App.cable.subscriptions.create { channel: "ChatChannel", room: "Best Room" },
"""
```
-### Passing Parameters to Channels
+### 채널에 매개변수 넘기기
-You can pass parameters from the client side to the server side when creating a
-subscription. For example:
+구독을 생성할 때 클라이언트 측에서 서버 측으로
+매개 변수를 전달할 수 있습니다. 다음의 예제를 보시죠:
```ruby
# app/channels/chat_channel.rb
@@ -290,8 +290,8 @@ class ChatChannel < ApplicationCable::Channel
end
```
-An object passed as the first argument to `subscriptions.create` becomes the
-params hash in the cable channel. The keyword `channel` is required:
+`subscriptions.create`에 첫번째 인자로 넘겨진 객체는
+params 해시이어야 합니다. `channel` 키워드는 생략할 수 없습니다.
```coffeescript
# app/assets/javascripts/cable/subscriptions/chat.coffee
@@ -313,8 +313,8 @@ App.cable.subscriptions.create { channel: "ChatChannel", room: "Best Room" },
```
```ruby
-# Somewhere in your app this is called, perhaps
-# from a NewCommentJob.
+# NewCommentJob 과 같은 애플리케이션 어딘가에서
+# 다음 처럼 호출됩니다.
ActionCable.server.broadcast(
"chat_#{room}",
sent_by: 'Paul',
@@ -322,10 +322,10 @@ ActionCable.server.broadcast(
)
```
-### Rebroadcasting a Message
+### 메시지를 재전송하기
-A common use case is to *rebroadcast* a message sent by one client to any
-other connected clients.
+한 클라이언트로부터 받은 메시지를 접속하고 있는 다른
+클라이언트에게 *재전송(rebroadcast)* 하는 경우도 많습니다.
```ruby
# app/channels/chat_channel.rb
@@ -349,25 +349,25 @@ App.chatChannel = App.cable.subscriptions.create { channel: "ChatChannel", room:
App.chatChannel.send({ sent_by: "Paul", body: "This is a cool chat app." })
```
-The rebroadcast will be received by all connected clients, _including_ the
-client that sent the message. Note that params are the same as they were when
-you subscribed to the channel.
+재전송을 하게 되면 접속 중인 모든 클라이언트에게 전송됩니다.
+이는 전송을 요청한 클라이언트 자신도 _포함합니다_.
+사용하는 매개 변수들은 채널에 구독할 때와 같습니다.
-## Full-Stack Examples
+## 풀 스택 예제
-The following setup steps are common to both examples:
+다음의 설정 순서는 두 가지 예시에서 공통적으로 해당됩니다:
- 1. [Setup your connection](#connection-setup).
- 2. [Setup your parent channel](#parent-channel-setup).
- 3. [Connect your consumer](#connect-consumer).
+ 1. [커넥션 설정](#connection-setup).
+ 2. [부모 채널 설정](#parent-channel-setup).
+ 3. [소비자를 연결](#connect-consumer).
-### Example 1: User Appearances
+### 예제 1: 사용자 접속을 표시하기
-Here's a simple example of a channel that tracks whether a user is online or not
-and what page they're on. (This is useful for creating presence features like showing
-a green dot next to a user name if they're online).
+이는 사용자가 온라인인지 아닌지, 사용자가 어떤 페이지를 보고 있는지
+추적하는 간단한 예제입니다. (이는 사용자들이 접속 중일 때에 그 사람
+이름의 옆에 녹색 점을 표시하는 기능 등을 구현할 때에 유용합니다)
-Create the server-side appearance channel:
+서버 측에 나타낼 채널을 생성하세요:
```ruby
# app/channels/appearance_channel.rb
@@ -390,34 +390,34 @@ class AppearanceChannel < ApplicationCable::Channel
end
```
-When a subscription is initiated the `subscribed` callback gets fired and we
-take that opportunity to say "the current user has indeed appeared". That
-appear/disappear API could be backed by Redis, a database, or whatever else.
+구독이 시작되면 `subscribed` 콜백이 시작되고, "현재 사용자가 접속중"
+이라고 알려줄 수 있게 됩니다. 이 표시 API를 Redis나 데이터베이스
+등과 연동할 수 있습니다.
-Create the client-side appearance channel subscription:
+클라이언트 측에 나타낼 채널 구독을 생성하세요:
```coffeescript
# app/assets/javascripts/cable/subscriptions/appearance.coffee
App.cable.subscriptions.create "AppearanceChannel",
- # Called when the subscription is ready for use on the server.
+ # 구독이 가능해지면 호출됨.
connected: ->
@install()
@appear()
- # Called when the WebSocket connection is closed.
+ # 웹소켓 연결이 닫히면 호출됨.
disconnected: ->
@uninstall()
- # Called when the subscription is rejected by the server.
+ # 구독이 서버로부터 거부되는 경우 호출됨.
rejected: ->
@uninstall()
appear: ->
- # Calls `AppearanceChannel#appear(data)` on the server.
+ # 서버의 `AppearanceChannel#appear(data)`를 호출.
@perform("appear", appearing_on: $("main").data("appearing-on"))
away: ->
- # Calls `AppearanceChannel#away` on the server.
+ # 서버의 `AppearanceChannel#away`를 호출.
@perform("away")
@@ -438,44 +438,44 @@ App.cable.subscriptions.create "AppearanceChannel",
$(buttonSelector).hide()
```
-##### Client-Server Interaction
+##### 클라이언트-서버간 상호작용
-1. **Client** connects to the **Server** via `App.cable =
-ActionCable.createConsumer("ws://cable.example.com")`. (`cable.js`). The
-**Server** identifies this connection by `current_user`.
+1. **클라이언트**는 **서버**에 `App.cable =
+ActionCable.createConsumer("ws://cable.example.com")`를 경유하여 연결됩니다.
+**서버**는 이 연결을 `current_user`로 인식합니다. (위치: `cable.js`)
-2. **Client** subscribes to the appearance channel via
-`App.cable.subscriptions.create(channel: "AppearanceChannel")`. (`appearance.coffee`)
+2. **클라이언트**는 `App.cable.subscriptions.create(channel: "AppearanceChannel")`
+을 경유하여 채널을 구독합니다. (위치: `appearance.coffee`)
-3. **Server** recognizes a new subscription has been initiated for the
-appearance channel and runs its `subscribed` callback, calling the `appear`
-method on `current_user`. (`appearance_channel.rb`)
+3. **서버**는 표시 채널에 새 구독이 시작된 것을
+인식하고 서버의 `subscribed` 콜백을 통해 `current_user`의
+`appear` 메소드를 호출합니다. (위치: `appearance_channel.rb`)
-4. **Client** recognizes that a subscription has been established and calls
-`connected` (`appearance.coffee`) which in turn calls `@install` and `@appear`.
-`@appear` calls `AppearanceChannel#appear(data)` on the server, and supplies a
-data hash of `{ appearing_on: $("main").data("appearing-on") }`. This is
-possible because the server-side channel instance automatically exposes all
-public methods declared on the class (minus the callbacks), so that these can be
-reached as remote procedure calls via a subscription's `perform` method.
+4. **클라이언트**는 구독이 성립된 것을 인식하고 `connected`를 호출합니다 (위치:
+`appearance.coffee`). 이를 통해 @install과 @appear가 호출됩니다. @appear는
+서버의 `AppearanceChannel#appear(data)`를 통해서 데이터 해시
+`{ appearing_on: $("main").data("appearing-on") }`를
+넘겨줍니다. 서버의 클래스에 선언되어 있는 (콜백을 제외한) 모든 퍼블릭
+메소드가 자동적으로 노출되기 때문에 가능합니다. 공개된 퍼블릭 메소드는
+perform 메소드를 사용하여 원격 프로시저로서 사용할 수 있습니다.
-5. **Server** receives the request for the `appear` action on the appearance
-channel for the connection identified by `current_user`
-(`appearance_channel.rb`). **Server** retrieves the data with the
-`:appearing_on` key from the data hash and sets it as the value for the `:on`
-key being passed to `current_user.appear`.
+5. **서버**는 `current_user`로 확인한 커넥션의
+채널에서 appear 액션에 대한 요청을 수신합니다.
+(위치: `appearance_channel.rb`) 서버는 데이터 해시에서
+`:appearing_on` 키를 사용하여 값을 꺼내어 `current_user.appear`에
+넘겨진 `:on` 키의 값으로 설정합니다.
-### Example 2: Receiving New Web Notifications
+### 예제 2: 새로운 알림을 수신하기
-The appearance example was all about exposing server functionality to
-client-side invocation over the WebSocket connection. But the great thing
-about WebSockets is that it's a two-way street. So now let's show an example
-where the server invokes an action on the client.
+이 예제에서는 웹소켓을 사용하여 서버로부터 클라이언트의
+기능을 원격으로 실행하는 동작을 다룹니다. 그런데
+웹소켓의 멋진 점은 양방향 통신이라는 것입니다.
+이번에는 서버에서 클라이언트의 액션을 호출해봅시다.
-This is a web notification channel that allows you to trigger client-side
-web notifications when you broadcast to the right streams:
+이 알림 채널은 올바른 스트림에 브로드캐스트를
+할 때 클라이언트에 알림을 표시합니다.
-Create the server-side web notifications channel:
+서버의 알림 채널을 만듭니다:
```ruby
# app/channels/web_notifications_channel.rb
@@ -486,22 +486,22 @@ class WebNotificationsChannel < ApplicationCable::Channel
end
```
-Create the client-side web notifications channel subscription:
+구독을 위한 클라이언트의 알림 채널을 만듭니다:
```coffeescript
# app/assets/javascripts/cable/subscriptions/web_notifications.coffee
-# Client-side which assumes you've already requested
-# the right to send web notifications.
+# 클라이언트 쪽으로 알림을 보낼 수 있는 권한을
+# 서버가 이미 가지고 있다고 가정합니다.
App.cable.subscriptions.create "WebNotificationsChannel",
received: (data) ->
new Notification data["title"], body: data["body"]
```
-Broadcast content to a web notification channel instance from elsewhere in your
-application:
+알림 채널 인스턴스로 어떤 내용을 브로드캐스트하는 것은
+애플리케이션의 어디에서라도 가능합니다:
```ruby
-# Somewhere in your app this is called, perhaps from a NewCommentJob
+# 이 코드는 애플리케이션의 어딘가(ex: NewCommentJob)에서 호출됨
WebNotificationsChannel.broadcast_to(
current_user,
title: 'New things!',
@@ -509,31 +509,31 @@ WebNotificationsChannel.broadcast_to(
)
```
-The `WebNotificationsChannel.broadcast_to` call places a message in the current
-subscription adapter's pubsub queue under a separate broadcasting name for each
-user. For a user with an ID of 1, the broadcasting name would be
-`web_notifications:1`.
+`WebNotificationsChannel.broadcast_to` 호출에서는
+현재 구독 어댑터의 pubsub 큐에 메시지를 추가합니다.
+이 때 사용자마다 서로 다른 브로드캐스트 이름이 사용됩니다.
+ID가 1인 사용자라면 브로드캐스트의 이름은 `web_notifications:1`입니다.
-The channel has been instructed to stream everything that arrives at
-`web_notifications:1` directly to the client by invoking the `received`
-callback. The data passed as argument is the hash sent as the second parameter
-to the server-side broadcast call, JSON encoded for the trip across the wire
-and unpacked for the data argument arriving as `received`.
+`received` 콜백이 호출되면, 이 채널은 `web_notifications:1`에
+도착한 것을 모두 클라이언트에게 전송합니다. 인자로서 넘겨진 데이터는
+서버의 브로드캐스트 호출의 두번째 인수로 넘겨지는 해시입니다.
+이 해시는 JSON으로 인코딩되어 전송되며, `received`로 수신할 때
+데이터 인자로부터 복원됩니다.
-### More Complete Examples
+### 더 자세한 예시
-See the [rails/actioncable-examples](https://github.com/rails/actioncable-examples)
-repository for a full example of how to setup Action Cable in a Rails app and adding channels.
+레일스 애플리케이션에 액션 케이블을 설정하는 방법과 채널을 추가하는 방법에 대해서는
+[rails/actioncable-examples](https://github.com/rails/actioncable-examples)에서 전체 예시를 볼 수 있습니다.
-## Configuration
+## 설정
-Action Cable has two required configurations: a subscription adapter and allowed request origins.
+액션케이블에는 구독 어댑터와 허가된 요청 호스트라는 두 개의 필수 설정이 있습니다.
-### Subscription Adapter
+### 구독 어댑터
-By default, Action Cable looks for a configuration file in `config/cable.yml`.
-The file must specify an adapter for each Rails environment. See the
-[Dependencies](#dependencies) section for additional information on adapters.
+기본적으로, 액션케이블은 `config/cable.yml`을 설정 파일로 인식합니다.
+이 파일은 각각의 레일스 환경마다 특정 어댑터를 지정해야고 있어야 합니다.
+어댑터에 관한 추가적인 정보는 [의존성](#dependencies) 부분을 참고해주세요.
```yaml
development:
@@ -547,56 +547,56 @@ production:
url: redis://10.10.3.153:6381
channel_prefix: appname_production
```
-#### Adapter Configuration
+#### 어댑터 설정
-Below is a list of the subscription adapters available for end users.
+아래는 최종사용자가 구독할 때에 사용할 수 있는 어댑터 목록입니다.
-##### Async Adapter
+##### Async 어댑터
-The async adapter is intended for development/testing and should not be used in production.
+async 어댑터는 개발/테스트 환경을 위한 것으로, 실제 프로덕션 환경에서는 사용하지 마세요.
-##### Redis Adapter
+##### Redis 어댑터
-The Redis adapter requires users to provide a URL pointing to the Redis server.
-Additionally, a `channel_prefix` may be provided to avoid channel name collisions
-when using the same Redis server for multiple applications. See the [Redis PubSub documentation](https://redis.io/topics/pubsub#database-amp-scoping) for more details.
+Redis 어댑터를 사용하려면 Redis 서버를 가리키는 URL을 사용자가 지정해주어야 합니다. 추가적으로, 다수의 애플리케이션이 같은
+Redis 서버를 사용할 때에 채널 이름이 충돌하는 것을 방지하기 위해 `channel_prefix`가 제공됩니다. 보다 자세한 내용은
+[Redis PubSub documentation](https://redis.io/topics/pubsub#database-amp-scoping)을 참고해주세요.
-##### PostgreSQL Adapter
+##### PostgreSQL 어댑터
-The PostgreSQL adapter uses Active Record's connection pool, and thus the
-application's `config/database.yml` database configuration, for its connection.
-This may change in the future. [#27214](https://github.com/rails/rails/issues/27214)
+PostgreSQL 어댑터는 액티브레코드의 커넥션 풀 을 사용합니다.
+따라서 애플리케이션의 `config/database.yml`에서 데이터베이스를 설정해야 합니다.
+이 부분은 가까운 시일 내에 변경이 있을 수도 있습니다. [#27214](https://github.com/rails/rails/issues/27214)
-### Allowed Request Origins
+### 허가된 요청 호스트
-Action Cable will only accept requests from specified origins, which are
-passed to the server config as an array. The origins can be instances of
-strings or regular expressions, against which a check for the match will be performed.
+액션케이블은 지정한 호스트의 요청만 수락합니다.
+이 호스트 목록은 배열의 형태로 서버 설정에 넘깁니다.
+각 호스트는 문자열이나 정규 표현식을 사용할 수 있습니다.
```ruby
config.action_cable.allowed_request_origins = ['http://rubyonrails.com', %r{http://ruby.*}]
```
-To disable and allow requests from any origin:
+모든 요청을 허가하려면 다음을 설정하세요:
```ruby
config.action_cable.disable_request_forgery_protection = true
```
-By default, Action Cable allows all requests from localhost:3000 when running
-in the development environment.
+개발 환경에서 실행 중일 때, 액션케이블은 기본적으로
+localhost:3000으로부터의 요청을 모두 허가합니다.
-### Consumer Configuration
+### 소비자 설정
-To configure the URL, add a call to `action_cable_meta_tag` in your HTML layout
-HEAD. This uses a URL or path typically set via `config.action_cable.url` in the
-environment configuration files.
+URL을 설정하기 위해서, HTML 레이아웃의 HEAD 태그 내에 `action_cable_meta_tag`을 추가하세요.
+이렇게 하면 URL이나 경로를 보통의 방식처럼 환경 설정 파일에서 `config.action_cable.url`을
+통해 설정된 것으로 간주하여 사용하게 됩니다.
-### Other Configurations
+### 기타 설정
-The other common option to configure is the log tags applied to the
-per-connection logger. Here's an example that uses
-the user account id if available, else "no-account" while tagging:
+설정을 위한 그 밖의 다른 공통 옵션은 커넥션별 로거에 적용되는 로그 태그 입니다.
+사용자 계정 ID를 사용할 수 있는 경우 사용 예시는 다음과 같습니다.
+사용자 계정 ID를 사용할 수 없다면, 태깅 중에는 "no-account"를 사용하세요:
```ruby
config.action_cable.log_tags = [
@@ -606,21 +606,21 @@ config.action_cable.log_tags = [
]
```
-For a full list of all configuration options, see the
-`ActionCable::Server::Configuration` class.
+설정 옵션의 전체 목록을 보려면,
+`ActionCable::Server::Configuration` 클래스를 확인하세요.
-Also, note that your server must provide at least the same number of database
-connections as you have workers. The default worker pool size is set to 4, so
-that means you have to make at least that available. You can change that in
-`config/database.yml` through the `pool` attribute.
+또한, 서버는 가지고 있는 worker의 개수와 동일한 수의 데이터베이스 연결을 제공해야 합니다.
+기본 worker의 pool 사이즈는 4 로 설정되어 있기 때문에,
+최소한 같은 수의 사용 가능한 연결을 확보해주어야 합니다.
+이는 `config/database.yml`의 `pool` 속성을 통해 변경할 수 있습니다.
-## Running Standalone Cable Servers
+## 독립 케이블 서버 실행하기
-### In App
+### 애플리케이션에서 실행하기
-Action Cable can run alongside your Rails application. For example, to
-listen for WebSocket requests on `/websocket`, specify that path to
-`config.action_cable.mount_path`:
+액션케이블은 레일스 애플리케이션과 함께 실행할 수 있습니다.
+예를 들어, `/websocket`에서 웹소켓 요청을 수신하는 경우에는
+`config.action_cable.mount_path`로 경로를 지정할 수 있습니다:
```ruby
# config/application.rb
@@ -629,20 +629,20 @@ class Application < Rails::Application
end
```
-You can use `App.cable = ActionCable.createConsumer()` to connect to the cable
-server if `action_cable_meta_tag` is invoked in the layout. A custom path is
-specified as first argument to `createConsumer` (e.g. `App.cable =
-ActionCable.createConsumer("/websocket")`).
+레이아웃에서 `action_cable_meta_tag`가 호출되고 있으면, 케이블 서버에 연결하기 위해
+`App.cable = ActionCable.createConsumer()`를 사용할 수 있습니다.
+`createConsumer`의 첫 번째 인자를 통해 path를 커스텀하여 지정 할 수 있습니다.
+(예시. `App.cable = ActionCable.createConsumer("/websocket")` )
-For every instance of your server you create and for every worker your server
-spawns, you will also have a new instance of Action Cable, but the use of Redis
-keeps messages synced across connections.
+생성한 서버의 모든 인스턴스와 서버가 생성한 모든 워커
+인스턴스에는 액션케이블의 새로운 인스턴스도 포함됩니다.
+커넥션 간의 메시지 동기화는 Redis를 통해서 이루어집니다.
-### Standalone
+### 독립된 서버에서 실행하기
-The cable servers can be separated from your normal application server. It's
-still a Rack application, but it is its own Rack application. The recommended
-basic setup is as follows:
+레일스 애플리케이션 서버와 액션케이블 서버를 나눌 수도 있습니다.
+액션케이블 서버는 Rack 애플리케이션입니다만, 독립된
+애플리케이션이기도 합니다. 추천하는 기본 설정은 다음과 같습니다.
```ruby
# cable/config.ru
@@ -652,41 +652,41 @@ Rails.application.eager_load!
run ActionCable.server
```
-Then you start the server using a binstub in `bin/cable` ala:
+이어서, `bin/cable`의 binstub을 사용하여 서버를 시작합니다:
```
#!/bin/bash
bundle exec puma -p 28080 cable/config.ru
```
-The above will start a cable server on port 28080.
+위 코드는 28080 포트에서 액션케이블 서버를 실행시킵니다.
-### Notes
+### 메모
-The WebSocket server doesn't have access to the session, but it has
-access to the cookies. This can be used when you need to handle
-authentication. You can see one way of doing that with Devise in this [article](http://www.rubytutorial.io/actioncable-devise-authentication).
+웹소켓 서버로부터 세션에 접근할 수 없습니다만, 쿠키에는 접근할 수 있습니다. 이를 사용해서 인증을 처리할
+수 있습니다. [이 글](http://www.rubytutorial.io/actioncable-devise-authentication)에서
+Devise와 함께 사용하는 방법을 확인할 수 있습니다.
-## Dependencies
+## 의존성
-Action Cable provides a subscription adapter interface to process its
-pubsub internals. By default, asynchronous, inline, PostgreSQL, and Redis
-adapters are included. The default adapter
-in new Rails applications is the asynchronous (`async`) adapter.
+액션케이블은 pubsub을 처리하기 위한 구독 어댑터 인터페이스를 제공합니다.
+기본 사항으로 비동기, 인라인, PostgreSQL, Redis
+등의 어댑터가 탑재되어 있습니다. 새 레일스
+애플리케이션의 기본 어댑터는 비동기(`async`) 어댑터입니다.
-The Ruby side of things is built on top of [websocket-driver](https://github.com/faye/websocket-driver-ruby),
-[nio4r](https://github.com/celluloid/nio4r), and [concurrent-ruby](https://github.com/ruby-concurrency/concurrent-ruby).
+루비 코드 구현체는 [websocket-driver](https://github.com/faye/websocket-driver-ruby),
+[nio4r](https://github.com/celluloid/nio4r), [concurrent-ruby](https://github.com/ruby-concurrency/concurrent-ruby)에 기반해 작성되었습니다.
-## Deployment
+## 배포
-Action Cable is powered by a combination of WebSockets and threads. Both the
-framework plumbing and user-specified channel work are handled internally by
-utilizing Ruby's native thread support. This means you can use all your regular
-Rails models with no problem, as long as you haven't committed any thread-safety sins.
+액션케이블은 웹소켓과 스레드의 조합으로 제작되어 있습니다.
+프레임워크 내부의 흐름과 사용자 지정 채널의 동작은 루비의 기본
+스레드를 통해 처리됩니다. 즉 스레드에 안전한 코드를 유지하는
+한, 모든 레일스의 정규 모델을 문제 없이 사용할 수 있습니다.
-The Action Cable server implements the Rack socket hijacking API,
-thereby allowing the use of a multithreaded pattern for managing connections
-internally, irrespective of whether the application server is multi-threaded or not.
+액션케이블 서버에는 Rack 소켓을 탈취(hijacking)하는 API가
+구현되어 있습니다. 이를 통해서, 애플리케이션 서버의 멀티 스레드
+사용 여부와 관계없이 내부의 커넥션을 멀티 스레드 패턴으로 관리합니다.
-Accordingly, Action Cable works with popular servers like Unicorn, Puma, and
-Passenger.
+따라서 액션케이블은 Unicorn, Puma, Passenger 의
+인기 있는 서버와 문제없이 연동될 수 있습니다.