2016년 12월 12일 월요일

socketcluster tutorial - 11. 성능 (Performance)

성능


벤치 마크


처리량 (SocketCluster v0.9.8)


이 테스트의 목적은 SocketCluster가 적절한 머신에서 얼마나 많은 JavaScript (JSON) 객체를 처리할 수 있는지를 보는 것이었습니다.

절차

이 CPU 벤치 마크에서 SocketCluster는 Linux를 실행하는 8 코어 Amazon EC2 m3.2xlarge 인스턴스에서 테스트하였습니다.

  • 100 명의 동시 클라이언트가 있을 때까지 매 초마다 새로운 클라이언트를 생성하였습니다.
  • 전송한 최대 메시지 수는 170k (클라이언트 당 초당 1700 개의 메시지)로 설정하였습니다.
  • 메시지는 완전히 양방향이었습니다 - 클라이언트는 JSON으로 캐스팅 된 JavaScript 객체를 포함하는 'ping'이벤트를 보내고 서버는 'pong'JavaScript 객체로 응답합니다. 이 객체에는 현재 워커가 지금까지 받은 총 ping의 수를 나타내는 'count'속성이 있습니다.
  • SocketCluster는 5 개의 로드 밸런서, 5 명의 워커 및 2 명의 브로커를 사용하도록 설정하였습니다.

관측



  • 로드 밸런서 모듈을 v0.9.12로 업그레이드하면 워커 간에 훨씬 더 균등한 분배가 이루어졌습니다. 이전 버전의 loadbalancer는 갑작스러운 트래픽 급증에도 반응이 없었습니다. 새로운 버전의 loadbalancer는 무작위 확률을 결정론적 '불운'보정으로 활용하는 알고리즘을 사용하여 부하가 워커 간에 균등하게 분산되도록 합니다.
  • 프로세스 설정은 이전 벤치 마크에서 제대로 조정되지 않았습니다. CPU 코어보다 많은 프로세스를 사용하는 것은 낭비입니다.
  • 더 적은 수의 프로세스를 사용하여 매우 양호한 부하로 평균 3.33을 만들었습니다 (가능한 8 개 중). 아마도 우리의 현재 설정으로 20만 개의 접속이 되도록 했을 것입니다. 로드 밸런서 5대, 워커 5개, 브로커 2개가 여전히 이상적이진 않습니다. 아마도 한 명의 워커 프로세스가 완벽한 균형을 이루었을 것입니다.

스크린샷



동시성 (SocketCluster v0.9.20)


이 테스트의 목적은 SocketCluster가 얼마나 많은 동시 사용자를 처리할 수 ​​있는지 추정하는 것이었습니다.

절차


SocketCluster는 Linux를 실행하는 8 코어 Amazon EC2 m3.2xlarge 인스턴스에 배포되었습니다. SocketCluster 클라이언트는 Linux를 실행하는 최대 32 코어 Amazon EC2 c3.8xlarge 인스턴스에서 실행되었습니다. 이것은 단일 시스템에서 42K 동시 사용자를 시뮬레이트 할 수 있도록 하기 위해 필요했습니다.

  • 가상 사용자 (클라이언트)는 초당 약 160의 속도로 생성 (연결)되었습니다.
  • 동시 가상 사용자의 최대 수는 42K로 설정되었습니다. 이는 서버가 아닌 클라이언트의 한계입니다.
  • 각 가상 사용자는 평균 6 초마다 'ping'메시지를 보냈습니다. 'ping'이벤트의 페이로드는 JSON으로 변환한 JavaScript 객체였으며 응답은 지금까지 현재 워커가 받은 총 Ping의 수를 포함하는 'pong'객체였습니다.
  • 표준 브라우저 (Chrome)가 SC 서버에 원격으로 연결되어 (때때로 ping을 보내서) 전체 테스트에서 서비스가 실제 성능을 발휘하는지 확인합니다. 또한 시간이 지남에 따라 증가하는 ping 수를 확인하는 데 사용되었습니다.
  • SocketCluster는 4 개의 로드 밸런서, 3 명의 워커 및 1 개의 브로커를 실행하도록 설정하였습니다.

관측


  • CPU(가장 바쁜 워커)는 끝에 거의 60%까지 최고조에 달했고 새로운 연결은 여전히 ​​생성되었습니다 (초당 160 회).
  • 42K로 연결이 완료되면 가장 바쁜 워커의 CPU 사용이 약 45 %
  • 브로커는 많은 작업을 하지 않았습니다. 실제로 7 개의 CPU 코어만 완전히 활용되었습니다.
  • 로드 평균은 2 점 미만 (가능한 8 점)이었으므로 더 많은 사용자를 확보할 여지가 충분했습니다.
  • 메모리 사용량은 CPU 사용량과 비교할 때 무시할 정도였습니다.
  • huge 32-core EC2 클라이언트 시스템은 42K 연결을 훨씬 넘어서지 못했습니다. 클라이언트의 CPU 사용량은 모든 32 코어에서 100 %에 가까워졌습니다. 특정 지점을 지나면 클라이언트는 지연되기 시작하고 서버의 부하가 감소합니다.

스크린샷


socketcluster tutorial - 6. 미들웨어 및 인증 (Middleware and authorization)

미들웨어 및 인증


SocketCluster를 사용하면 클라이언트는 JavaScript를 사용하여 특정 채널로 데이터를 청취하고 발행하여 메시지를 서로 공유할 수 있습니다. 기본적으로 누구나 자신이 좋아하는 채널에 데이터에 수신하고 게시할 수 있습니다. 일부 시스템에서는 이것이 문제가 되지 않지만 대부분의 시스템은 사용자가 서로 상호 작용할 수 있는 방법을 규제하기 위해 어느 정도의 접근 제어가 필요합니다. 대부분의 시스템은 적절한 접근 권한을 시행하기 위해 연결을 인증하고 권한을 부여하는 방법이 필요합니다. 미들웨어 기능은 이러한 모든 작업을 수행할 수 있는 깔끔한 중앙 집중식 방식을 제공합니다.

SocketCluster에서 모든 실시간 이벤트는 서버에서 처리하기 전에 미들웨어 기능을 통과해야 합니다. SocketCluster는 다양한 종류의 상호 작용을 처리할 수 있는 다양한 종류의 미들웨어 라인을 제공합니다. 가장 유용한 미들웨어 라인은 워커 프로세스에 있지만 로드 밸런서(HTTP 용)에 의해 노출되는 미들웨어 라인이 있습니다. 이 튜토리얼에선 워커(실시간) 미들웨어에만 초점을 맞춥니다.

워커는 실시간 scServer 객체를 통해 미들웨어를 노출합니다. 이 객체는 worker.getSCServer()를 사용하여 액세스 할 수 있습니다.

미들웨어 기능을 서버에 추가하려면 다음을 사용해야 합니다.
scServer.addMiddleware (middlewareType, middlewareFunction);
scServer에서 사용할 수있는 미들웨어 유형은 다음과 같습니다.
scServer.MIDDLEWARE_HANDSHAKE
scServer.MIDDLEWARE_SUBSCRIBE
scServer.MIDDLEWARE_PUBLISH_IN
scServer.MIDDLEWARE_PUBLISH_OUT
scServer.MIDDLEWARE_EMIT
middlewareFunction에 전달한 req인자는 사용한 미들웨어의 종류에 따라 다릅니다. 다음 예제의 err객체는 JavaScript의 Error객체를 상속한 사용자 정의 클래스를 기반으로 합니다. 서버에서 스택 트레이스를 사용하지 않는 경우 폼에서 {name: 'MyCustomError', message: 'This is a custom error'} (또는 추가 사용자 정의 속성을 사용하여)와 같은 일반 객체를 next(err)에게 전달할 수 있습니다. 다음은 각 종류의 미들웨어를 사용하는 방법을 보여주는 몇 가지 샘플 코드 스니펫입니다.

핸드쉐이크

// WebSocket 핸드쉐이크용
wsServer.addMiddleware(wsServer.MIDDLEWARE_HANDSHAKE,
  function (req, next) {
    // ...
    if (...) {
      next() // Allow
    } else {
      var err = new MyCustomHandshakeFailedError('Handshake failed');
      next(err); // Block
      // next(true); // 서버 측에서 경고하지 않고 조용히 next() 블록에 true를 전달합니다.
    }
  }
);

구독하기

기본 인증 토큰 만료 오류로 실패합니다.
// Error 객체에 사용자 정의 속성을 가질 수 있습니다.
// 서버 측에서 경고를하지 않고 조용히 next () 블록에 true를 전달합니다.
wsServer.addMiddleware(wsServer.MIDDLEWARE_SUBSCRIBE,
  function (req, next) {
    // ...
    if (req.authTokenExpiredError) {
      next(req.authTokenExpiredError); // 기본 인증 토큰 기간 만료 오류로 실패
    } else if (...) {
      next() // Allow
    } else {
      var socketId = req.socket.id;
      var err = new MyCustomSubscribeFailedError(socketId + ' cannot subscribe to channel ' + req.channel);
      // You can have custom properties on your Error object.
      err.code = 1234;
      next(err); // Block
      // next(true); // 서버 측에서 경고하지 않고 조용히 next() 블록에 true를 전달합니다.
    }
  }
);

발행

SC는 게시를 위해 두 가지 미들웨어 라인을 지원합니다. MIDDLEWARE_PUBLISH_IN은 게시한 메시지를 처리한 후 (개별 소켓으로 보내기 직전) MIDDLEWARE_PUBLISH_OUT가 캡처한 메시지를 처리하는 동안 브로커에 도달하기 전에 서버에 도달할 때 인바운드 메시지를 캡처합니다. MIDDLEWARE_PUBLISH_OUT을 사용하면 메시지가 특정 소켓에 도달하는 것을 차단할 수 있습니다. 이 경우에는 메시지를 게시한 소켓이 자신의 메시지를 받지 않도록 메시지와 미들웨어를 설계할 수 있습니다.

Publish In

wsServer.addMiddleware(wsServer.MIDDLEWARE_PUBLISH_IN,
  function (req, next) {
    // ...
    if (...) {
      next() // Allow
    } else {
      var err = MyCustomPublishInFailedError(req.socket.id + ' cannot publish channel ' + req.channel);
      next(err); // Block
      // next(true); // 서버 측에서 경고하지 않고 조용히 next() 블록에 true를 전달합니다.
    }
  }
);

Publish out

wsServer.addMiddleware(wsServer.MIDDLEWARE_PUBLISH_OUT,
  function (req, next) {
    // ...
    if (...) {
      next() // Allow
    } else {
      var err = MyCustomPublishOutFailedError('Blocked publishing message out to ' + req.socket.id);
      next(err); // Block with notice
      // next(true); // 서버 측에서 경고하지 않고 조용히 next() 블록에 true를 전달합니다.
    }
  }
);

전송하기

wsServer.addMiddleware(wsServer.MIDDLEWARE_EMIT,
  function (req, next) {
    // ...
    if (...) {
      next() // Allow
    } else {
      var err = MyCustomEmitFailedError(req.socket.id + ' is not allowed to emit event ' + req.event);
      next(err); // Block
      // next(true); // 서버 측에서 경고하지 않고 조용히 next() 블록에 true를 전달합니다.
    }
  }
);
next() 함수는 언제든지 (비동기가 좋습니다) 호출할 수 있지만, 결과적으로 호출하는 것을 확인해야 합니다. 그렇지 않으면 클라이언트의 subscribe/ publish/emit 액션이 단순 타임아웃이나 클라이언트 쪽에서 원인을 알 수 없는 타임아웃 오류를 발생할 것입니다. 클라이언트가 뭔가를 하지 못하도록 차단하려면 명시적 오류를 주는 것이 더욱 다루기 쉽습니다.

socketcluster tutorial - 10. 복수 호스트 확장 (Scaling across multiple hosts)

복수 호스트 확장


SocketCluster를 사용하면 수직적(시스템/호스트의 여러 CPU 코어에 걸쳐)으로 수평적으로(여러 호스트에 걸쳐) 확장할 수 있습니다. 수평으로 확장하려면 SCC(권장)를 사용하거나 처음부터 직접 솔루션을 구현할 수 있습니다. SCC를 사용하는 경우 SC가 시스템에서 채널 데이터를 동기화하는 방법에 대한 구현 세부 정보를 배울 필요가 없습니다.

SCC

SCC는 2016 년 9 월에 도입되었습니다. SC는 여러 호스트에서 SC를 확장하기 위한 컴포넌트 모음입니다.

SCC는 설치가 쉬우며 뒤에서 일어나는 일에 대해 많이 알 필요 없이 수평적 확장성을 제공합니다. Kubernetes위에 SCC를 실행하면 위아래로 스케일 업이 자동으로 처리됩니다. SCC 사용에 대한 전체 안내서는 여기에 있습니다. SCC를 사용하는 경우 '수동으로 크기 조정'에 대한 아래 섹션을 읽을 필요가 없습니다.

수동으로 크기 조정

수평적 확장의 목표는 최적의 방법으로 트래픽을 모든 사용 가능한 시스템에 분산하는 것입니다. SocketCluster의 컨텍스트에서 수평 확장은 두 가지 특정 문제로 귀결됩니다.

  1. 들어오는 클라이언트 연결을 보낼 호스트를 어떻게 선택합니까?
  2. 한 클라이언트가 채널에 데이터를 게시할 때 다른 호스트의 해당 채널에 가입 한 다른 클라이언트가 채널 데이터를 실시간으로 수신하는지 어떻게 확인할 수 있습니까?
첫 번째 과제에 접근하는 데는 여러 가지 방법이 있습니다. 예를 들면 다음과 같습니다.

무작위로 호스트 URL을 선택하고 클라이언트 소켓의 connect() 메서드에 옵션으로 전달하여 각 클라이언트를 호스트 중 하나에 직접 보낼 수 있습니다.
로드 밸런서를 사용하여 들어오는 연결을 대상 호스트에 고르게 분산할 수 있습니다. 타사 서비스를 사용할 수도 있고 직접 설정할 수도 있습니다. SocketCuster v1.xx를 사용하는 경우 sticky로드 밸런서(예 : IP 주소 기반의 Sticky)를 사용해야 합니다. - 버전 v2.0.0 이상에서는 사용하지 않아도 됩니다. (이는 우리가 stateful HTTP 폴링 지원하지 않는 이유입니다). 사용하는 로드 밸런서는 WebSocket을 지원해야 합니다. HAProxy와 NGINX의 새로운 버전을 사용하세요. SC와 함께 작동하도록 설정하고 최적화하기 쉬운 것으로 LoadBalancer.js도 있습니다.

서로 다른 컴퓨터에 연결된 클라이언트가 동일한 pub/sub 채널을 공유할 수 있게 하려면 실시간으로 별도의 SocketCluster 인스턴스 (호스트) 간에 채널을 동기화하는 효율적인 방법이 필요합니다. 이를 위해 SocketCluster는 brokerController 파일 (broker.js)에 Broker 객체를 제공하여 이를 정확히 수행 할 수 있습니다. SocketCluster는 인스턴스 채널을 동기화할 수 있는 인터페이스만 제공합니다. 이 기술을 구현하기 위해 어떤 기술/구현을 사용하든 상관하지 않습니다. pub/sub를 지원하고 분산 클러스터로 실행할 수 있는 한 MQTT(예 : Mosquitto), AMQP (예 : RabbitMQ), ZeroMQ 및 Redis가 모두 가능한 옵션입니다. 이러한 서비스를 설정하는 방법에 대한 자세한 내용은 이 가이드의 범위를 벗어납니다. 이러한 기술/프로토콜 중 일부를 읽거나 서드파티 서비스를 사용해야 합니다.

여러 대의 머신으로 확장할 수 있는 작업/서브 클러스터가 있다고 가정하면 SC 인스턴스/머신 간의 실제 동기화는 매우 간단합니다 - SocketCluster의 브로커 프로세스를 통해 수행할 수 있습니다 - 자세한 정보는 Broker API의 이벤트 섹션을 읽으십시오. 결과적으로 MQ 서비스는 SocketCluster 인스턴스 간의 연결 고리처럼 작동합니다. 또한 외부 서비스가 SocketCluser 채널과 동일한 시스템의 일부인 것처럼 상호 작용할 수 있습니다.

분산 MQ 서비스를 실행한 후에는 원하는 클라이언트를 사용하여 브로커 프로세스와 메시지 대기열 서비스 간의 이벤트를 릴레이 하면 됩니다. 설정은 간단합니다.

  1. 브로커 인스턴스에서 'subscribe'이벤트가 발생하면 MQ 클라이언트에서 MQ 서비스의 해당 채널을 구독해야 합니다.
  2. 브로커가 '구독 취소'이벤트를 발생하면 MQ 서비스에서 해당 채널의 구독을 취소해야 합니다.
  3. MQ 클라이언트에서 일부 채널 데이터를 수신할 때마다 broker.publish(channelName, data)를 호출합니다.

'subscribe'및 'unsubscribe'이벤트는 개별 클라이언트 소켓에 대해 트리거 되지 않습니다. 이는 워커 프로세스에 의해 시작됩니다. 작업자는 언제 브로커에 구독/탈퇴해야 하는지 선택합니다. '구독'이벤트가 발생하면 현재 브로커가 해당 채널에 대한 책임이 있습니다. '탈퇴'이벤트는 이 브로커가 더 이상이 채널에 책임이 없음을 나타냅니다.

SC 인스턴스에는 각각 여러 브로커 프로세스가 있을 수 있습니다. 이 경우 각 브로커는 최종 클라이언트에서 사용하는 모든 채널의 하위 집합을 담당합니다. 어댑터를 작성할 때 모든 채널이 동일한 브로커를 통과한다고 절대 가정해서는 안됩니다.

마지막 고려 사항으로 대기 시간을 최소화하기 위해 SC 인스턴스 (또는 가능하면 동일한 데이터 센터 내부)와 가까운 곳에 MQ 서비스를 배포하는 것이 가장 좋습니다.

Videos by Nick Kotenberg

017 NodeJS Socketcluster Horizontal Scaling
018 NodeJS Socketcluster Horizontal Scaling with Loadbalancer

socketcluster tutorial - 9. SSL을 적용한 상용 서비스 운영(Running in production (with SSL))

SSL을 적용한 상용 서비스 운영


SocketCluster에 시스템을 구축할 때 마스터 프로세스(server.js)에 런타임 구현을 배치하지 않는 것이 중요합니다. 이러한 구현은 worker(worker.js) 내부에 배치하는 것이 좋습니다. 마스터 프로세스와 달리 워커는 충돌할 때마다 (오류가 발생하지 않는 경우) 자동으로 재발행하고 서비스 중단을 최소화됩니다. 일반적으로 워커는 재발생하는데 1 초 미만이 걸리므로 사용자에게 투명해야 합니다. 마스터 프로세스는 일반적으로 초기 실행 구현을 넣고 장시간 실행되는 데몬 프로세스를 생성하기에 좋은 곳이지만 일단 시스템이 실행되면 오류가 발생하기 쉬운 논리를 실행하는데 이 프로세스를 사용하지 않아야합니다.

이러한 규칙을 따르는 경우 Node 명령을 사용하여 직접 SocketCluster 서버를 실행하면 실제 운영 환경에서 정상적으로 작동합니다. (인수 포함 예제).
nohup node server.js -w 2 -s 2 &
안심할 수 있도록 master를 자동으로 재생성하려면 forever를 사용하십시오.
npm install -g forever
설치한 후 다음과 같이 실행하십시오.
forever start --killSignal=SIGTERM server.js -w 2 -s 2
어떤 경우든 서버 기반 코드를 강제로 업데이트하기 위해 거의 다운타임 없는 배포를 수행하는 경우 마스터 프로세스에 SIGUSR2 신호를 보낼 수 있습니다. 자세한 내용은 이 문제를 참조하십시오.

SSL

프로덕션 환경에서 SC를 실행할 때 고려해야 할 또 다른 중요한 점은 일부 오래된 프록시가 WebSocket 트래픽을 차단할 수 있다는 것입니다. 이 문제를 방지하려면 SC 인스턴스에 키/인증서 SSL쌍을 제공하여 HTTPS/WSS를 통해 앱을 제공해야합니다.

SSL/TLS를 사용하도록 SC를 구성하려면 부팅 옵션을 설정해야합니다. '프로토콜'을 'https'로 설정하고 인증서 및 키가 포함 된 개체를 'protocolOptions'에 제공하십시오. protocolOptions 객체는 Node.js의 https 서버에 전달하는 options 객체와 정확히 동일합니다. 여기를 참고하십시오.

SocketCluster를 Kubernetes 환경에 배포하는 경우 server.js에서 TLS/ SSL 자격 증명을 지정할 필요가 없습니다. TLS / SSL은 K8에서 제공하는 ingress load balancer에서 처리됩니다. SCC를 참조하십시오.

socketcluster tutorial - 8. SocketCluster로 풀스택 발행/구독 (Full stack pub/sub with SocketCluster)

SocketCluster 풀스택 펍섭(발행/구독)


Socket.io 스타일의 emit/on 기능 외에도 SocketCluster를 사용하면 JavaScript(NodeJS 서버)를 사용하여 클라이언트 또는 서버의 실시간 pub/sub 채널과 상호 작용할 수 있습니다. 미들웨어 기능을 정의함으로써 SC는 실시간 데이터를 완벽하게 제어 할 수 있습니다. 미들웨어는 클라이언트가 특정 채널을 구독하고 게시하는 것을 차단하는 데 사용할 수 있지만 다른 클라이언트에 도달하기 전에 실시간 스트림을 백엔드로 변환하는데도 사용할 수 있습니다.

이 다이어그램은 SC v1.x.x의 아키텍처를 나타냅니다. SC v2.0.0+는 고정 로드 밸런서 계층(sticky load balancer layer)이 없습니다. 대신 워커는 동일한 포트를 공유하고 어느 포트가 가장 바쁜지를 기준으로 새로운 연결을 선택합니다. 다이어그램은 조금 일반적이지만 채널 1, 채널 2, 채널 3 ...은 고객이 참여할 수있는 다양한 대화방입니다. 각 방은 '수학', '물리학' , '화학'...과 같은 특정 ​​주제를에 집중할 수 있습니다, '물리학'방에 게시한 모든 메시지를 듣기 위해서는 클라이언트에서 다음과 같이 해야 합니다.
// SocketCluster API v1.0.0
var physChannel = socket.subscribe('physics');
physChannel.watch(function (data) {...});
물리학 방에 메시지를 전달하기 위해선 다음과 같이 호출합니다:
socket.publish('physics', messageData);
... 혹은
physChannel.publish(messageData);
여러 사용자가 채널을 공유 할 필요는 없습니다. 개별 사용자를 위해 채널을 설정할 수 있습니다. 예를 들어 사용자 이름이 'bob123'인 사용자는 'bob123'채널을 구독하고 시청할 수 있습니다. 그러면 bob123으로 데이터를 보내려는 다른 사용자는 다음과 같이 간단하게 호출할 수 있습니다:
socket.publish('bob123', {from: 'alice456', message: 'Hi Bob!'});
기본적으로 SC는 누구나 원하는 채널을 구독하고 게시할 수 있습니다. 서버에서 미들웨어를 지정하여 특정 사용자가 특정 이벤트를 구독, 게시 또는 전송하는 것을 허용 또는 차단할 수 있습니다. 예를 들면:
scServer.addMiddleware(scServer.MIDDLEWARE_SUBSCRIBE, function (req, next) {
  // ...
  if (...) {
    next(); // Allow
  } else {
    next(req.socket.id + ' is not allowed to subscribe to ' + req.channel); // Block
  }
});
scServer.addMiddleware(scServer.MIDDLEWARE_PUBLISH_IN, function (req, next) {
  // ...
  if (...) {
    next(); // Allow
  } else {
    next(req.socket.id + ' is not allowed to publish to the ' + req.channel + ' channel'); // Block
  }
});
scServer.addMiddleware(scServer.MIDDLEWARE_EMIT, function (req, next) {
  // ...
  if (...) {
    next(); // Allow
  } else {
    next(req.socket.id + ' is not allowed to emit the ' + req.event + ' req.event'); // Block
  }
});
또한 SocketCluster는 이벤트를 클라이언트에 발행할 수 있는 서버 측(scServer.exchange)의 Exchange 객체를 제공합니다:
scServer.exchange.publish(eventName, data, cb);
전송한 이벤트는 소켓의 반대편(즉, 서버 → 클라이언트 또는 클라이언트 → 서버)으로만 전송됩니다. 반면에 채널에 발행한 데이터는 구독중인 모든 클라이언트 소켓으로 전송됩니다 (다른쪽엔 아무 것도 보내지 않습니다!).

클라이언트 소켓을 채널을 구독하려면 다음과 같이 하면 됩니다.
var channelObject = socket.subscribe(channelName);
그러면 들어오는 채널 데이터를 처리하기 위해 아래와 같이 합니다.
channelObject.watch(handlerFn);
클라이언트가 채널 이벤트를 수신하려면 구독 요청이 SUBSCRIBE 미들웨어를 통과해야합니다.

socketcluster tutorial - 7. 실패 처리 (Handling failure)

실패 처리


프로덕션의 실시스템은 시스템 실패를 처리 할 수 있어야합니다. 고려해야 할 가장 일반적인 실패 원인 중 하나는 연결 불량에 대한 가능성입니다.

SC의 이벤트 관련 메소드는 서버가 액션을 확인할 때 '콜백'함수를 최종 인수로 사용합니다. 메서드가 실패하면 콜백은 인수로 오류를 받습니다.이 경우 메서드 호출을 다시 시도하거나 사용자에게 메시지를 표시하여 문제를 알릴 수 있습니다.

다양한 오류를 처리하는 방법은 다음과 같습니다. (샘플 코드)

Client측

보내기

// Client code
socket.emit('ping', 'This is a ping', function (err) {
  if (err) {
    // 보내기 이벤트 실패, 재시도 혹은 사용자에게 계속할지 여부를 물어봄.
  } else {
    // 보내기 이벤트 성공
  }
});
콜백 인수를 전달하지 않으면 emit 메소드가 실패하지 않습니다. 이 경우 emit 호출은 이벤트를 중요도 낮음 (휘발성)으로 처리합니다. 이 기능은 초당 여러 번 이벤트를 내보내고 가끔 실패하는 경우 신경 쓰지 않는 경우에 유용합니다. emit 메소드에 콜백을 전달하면 상대에게 명시적으로 응답을 보내야 합니다. (그렇지 않으면 콜백이 시간 초과됩니다):
// Server code
socket.on('ping', function (data, res) {
  // ...
  if (success) {
    res(null, 'Success'); // 성공 메시지 돌려주기
  } else {
    res('Error message'); // 오류 반환
  }
});
res 함수의 첫 번째 인수는 오류(모든 JSON 호환 타입 또는 객체)입니다. 일반 메시지(오류 없음)를 보낼  경우 첫 번째 인수를 null로 해야합니다. 원하는 경우: res (123, 'This is the error message') 이와 같이 첫 번째 인수를 오류 코드로 사용할 수 있습니다.

발행하기

// Client code
socket.publish('pong', 'This is a pong', function (err) {
  if (err) {
    // 발행 실패, 재시도 혹은 사용자에게 계속할지 여부를 물어봄.
  } else {
    // 발행 성공
  }
});

구독하기

// Client code
var pongChannel = socket.subscribe('pong');

pongChannel.on('subscribeFail', function (err, channelName) {
  // 구독 실패 처리
});

pongChannel.on('subscribe', function (channelName) {
  // 구독 성공 처리
});

// pong 채널에서 발행한 데이터 다루기
pongChannel.watch(function (data) {
  // pong 채널이 데이터를 발행할 때 마다 실행합니다.
});

Server-side

보내기

// Server code
socket.emit('ping', 'This is a ping', function (err) {
  if (err) {
    // Failed to emit event, retry or log?
  } else {
    // Event was emitted successfully
  }
});
콜백을 제공하면 클라이언트에서 응답을 보내야합니다:
// Client code
socket.on('ping', function (data, res) {
  // ...
  if (success) {
    res(null, 'Success'); // 성공 메시지 돌려주기
  } else {
    res('Error message'); // 오류 반환
  }
});

발행하기

// Server code
socket.exchange.publish('pong', 'This is a pong', function (err) {
  if (err) {
    // 발행 이벤트 실패. 재시도 혹은 로그?
  } else {
    // 이벤트 성공
  }
});

socketcluster tutorial - 5. 인증 (Authentication)

인증


개요


v1.3.0 이전에는 SocketCluster의 인증이 세션을 중심으로 돌아갔습니다. v1.3.0부터 인증은 JSON 웹 토큰 (JWT)을 기반으로합니다. SC의 인증 토큰 시스템은 다음 문제를 해결하도록 설계되었습니다.

사용자가 자격 증명을 다시 입력할 필요없이 연결이 끊어진 상태를 복구한 후 로그인 상태를 유지할 수 있습니다.
하나만 사용하여 로그인하면 열려있는 모든 브라우저 탭에서 사용자를 인증 할 수 있습니다. (여러 브라우저 탭간에 인증 토큰 공유).
SC의 인증 시스템에 대한 중요한 설계 고려 사항은 작업해야하지만 특정 데이터베이스 엔진이나 기본 데이터 (사용자 계정 정보 포함)와 완전히 독립적이어야한다는 것입니다. 이를 달성하기 위해 SC는 JWT 인증 토큰의 개념을 도입해야했습니다.

간단히 말해서, 인증 토큰은 서버에서 비밀 authKey로 서명하고 인증 (로그인) 프로세스의 일부로 클라이언트에 전송하는 사용자 정의 Object/JSON입니다 (SocketCluster 생성자의 authKey 옵션은 여기 참조). 토큰의 데이터는 클라이언트에 제공할 때 서명하므로 토큰을 무효화하지 않고 토큰을 수정할 수 없습니다. 즉, 서버 소켓에 유효한 auth 토큰이 첨부되어 있으면 (socket.authToken 참조) 클라이언트의 토큰이 서버에 의해 서명되었으므로 서버의 데이터가 유효하다는 것을 알 수 있습니다.

인증 토큰에 대해 주의해야 할 중요한 사항 중 하나는 클라이언트가 성공적으로 인증 된 이후에 클라이언트에 제공해야하며 클라이언트와 서버 사이에 비밀로 유지되어야합니다 (다른 클라이언트와 공유되지 않음). SC의 인증 토큰은 특정 사용자와 관련된 모든 종류의 액세스 제어 정보를 저장하는 데 사용할 수 있습니다. 일반적으로 사용자 이름 데이터만 포함하는 간단한 토큰을 만드는 것으로 충분합니다:
{
  username: 'bob123'
}

인증 절차


SC에서 인증을 구현하는 올바른 방법은 하나가 아닙니다. WebSocket 연결 전에 HTTP를 통해 인증할 수 있으며 나중에도 할 수 있습니다.

HTTP-기반 절차
HTTP 기반 인증에 대한 자세한 내용은 이 토론을 참조하십시오.


WebSocket-기반 절차
웹소켓 기반 인증 절차에 대한 샘플입니다:
// Client code
socket = socketCluster.connect();
// 'connect'이벤트는 boolean 형인 'isAuthenticated' 속성이
// 있는 상태 객체를 전달합니다. 연결이 설정된 시점에 소켓이 유효한
//  토큰을 전달하면 true입니다.
// 핸드 셰이크 중에 JWT 인증에 실패하면 상태 객체에
// 'authError'속성 (Error 객체가 있음)을 포함 할 수 있습니다.
socket.on('connect', function (status) {
  if (status.isAuthenticated) {
    // goToMainScreen();
  } else {
    // goToLoginScreen();
  }
}
사용자가 인증되지 않아 로그인 화면으로 전송된다고 가정합니다. 우리는 클라이언트에서 '로그인'이벤트를 발생시켜 로그인합니다.
// Client code
var credentials = {
  username: 'alice123',
  password: 'thisisapassword654'
};
socket.emit('login', credentials, function (err) {
  // 이 콜백은 서버 응답을 처리합니다.
  // 필요하면 별도의 'loginResponse'이벤트를 수신할 수 있지만
  // 이와 같은 콜백 전달 패턴이 조금 더 효율적입니다.
  if (err) {
    // showLoginError(err);
  } else {
    // goToMainScreen();
  }
});  
그런 다음 서버에 로그인을 처리 할 수있는 몇 가지 코드가 있습니다:
// Server code
// 이는 당신이 MySQL을 데이터 베이스로 사용하는 경우를
// 살짝 단순화한 버전입니다.
socket.on('login', function (credentials, respond) {
  var passwordHash = sha256(credentials.password);
  var userQuery = 'SELECT * FROM Users WHERE username = ?';
  mySQLClient.query(userQuery, [credentials.username], function (err, rows) {
    var userRow = rows[0];
    var isValidLogin = userRow && userRow.password === passwordHash;
    if (isValidLogin) {
      respond();
      // 이렇게 하면 클라이언트에게 토큰을 제공하므로
      // 연결이 끊어 지거나 나중에 앱을 다시 방문 할 때
      // 다시 로그인 할 필요가 없습니다.
      socket.setAuthToken({username: credentials.username, channels: userRow.channels});
    } else {
      // Passing string as first argument indicates error
      respond('Login failed');
    }
  });
});

토큰 확인 및 사용

HTTP 또는 WebSocket 인증 절차 여부에 관계없이 동일한 방식으로 JWT 토큰을 검증하고 읽을 수 있습니다. SC가 토큰을 설정하거나 캡처한 후 이를 사용하는 가장 좋은 방법은 미들웨어 기능을 사용하는 것입니다 (예: 게시 미들웨어 사용):
// Server code
wsServer.addMiddleware(wsServer.MIDDLEWARE_PUBLISH_IN, function (req, next) {
  var authToken = req.socket.authToken;
  if (authToken && authToken.channels.indexOf(req.channel) > -1) {
    next();
  } else {
    next('You are not authorized to publish to ' + req.channel);
  }
});
이 경우 토큰에는이 게시 작업을 인증하는 데 필요한 모든 정보를 포함하지만 토큰 자체에 채널 목록을 저장할 필요는 없습니다. 사용자 ID나 이름이 있는 경우 데이터베이스를 확인할 수 있습니다. SC의 미들웨어에 대한 자세한 정보는 미들웨어 및 권한 섹션을 참조하십시오.

WebSocket 연결을 설정하기 전에 HTTP를 통해 인증을 수행하려면 직접 토큰을 처리해야합니다. 이 댓글을 참조하십시오. 이제 SC는 서버 측에서 토큰을 서명(생성)하고 검증하기위한 기본 'AuthEngine'을 제공합니다 - 'worker.auth'속성에서 workerController (worker.js)에 접근할 수 있습니다 - 여기 구현을 참조하십시오: 기본값 서버 인증 엔진. Node.js JSON 웹 토큰 라이브러리에 대한 자세한 정보는 jsonwebtoken에서 찾을 수 있습니다.

Videos by Nick Kotenberg

013 Client side logins authentication with SocketCluster with the client

2016년 12월 11일 일요일

socketcluster tutorial - 4. 디버깅 (Debugging)

디버깅


일반적인 NodeJS 프로세스를 디버그하는 것과 거의 같은 방법으로 SC 프로세스를 디버그 할 수 있습니다. 유일한 차이점은 SC에는 다양한 방식으로 서로 상호 작용하는 여러 종류의 프로세스가 있기 때문에 일반적으로 동시에 모두를 디버그하는 일은 없습니다. 이러한 이유로 SC에서는 --debug-workers--debug-brokers CLI 인수를 제공하여 워커와 브로커를 각각 디버그 할 수 있습니다. Node.js 버전 6.3.0 이상을 사용하는 경우 --inspect-workers--inspect-broker를 사용하면 외부 디버거를 실행할 필요가 없습니다.

저, Node.js v0.11.0 + (가장 최근의 안정 버전)을 사용하고 있는지 확인하십시오.

Node-inspector를 전역으로 설치하십시오 (Node.js v6.3.0 이상인 경우 이 단계를 건너 뜁니다).
npm install -g node-inspector
그런 다음 콘솔 창에서 다음을 사용하여 실행하십시오:
node-inspector
^ 전체 디버깅 세션에 걸쳐 이 콘솔을 자체 콘솔 (또는 백그라운드)에서 실행해야합니다 (개별 디버그 사이에서 다시 시작할 필요가 없습니다).

디버깅을 시작하려면 새로운 콘솔을 열어야합니다. Node를 사용하여 server.js 파일을 실행할 때 --debug-workers, --debug-broker, --inspect-workers 또는 --inspect-brokers 인수를 전달해야합니다. 서버 파일 이름 에 플래그를 추가하십시오. 그렇지 않으면 작동하지 않습니다.

예를 들면
node server --debug-workers
혹은
node server --debug-brokers
또는 (Node.js version >= 6.3.0)
node server --inspect-workers
또는 (Node.js version >= 6.3.0)
node server --inspect-brokers
첫 번째 워커의 기본 디버그 포트는 5859이고 두 번째 워커는 5860입니다 (각 워커마다 하나씩 증가합니다) - 디버그 메시지를 콘솔에 출력하여 어떤 디버그 포트가 열려 있는지 알려줍니다.

첫 번째 작업자의 디버그 콘솔을 열려면 이 주소를 Chrome 브라우저 (디버그 포트 5859)에 삽입해야 합니다. http://127.0.0.1:8080/debug?ws=127.0.0.1:8080&port=5859

Node.js> = v6.3.0 인 경우 콘솔에 제공된 두 번째 URL을 복사하여 첫 번째 워커를 디버그합니다 (제공된 첫 번째 URL은 master workerCluster 프로세스 용임).

또한 워커를 위한 사용자 시작 포트를 지정할 수도 있습니다. 첫 번째 포트는 워커에 할당됩니다. 클러스터 마스터 - SC 작업자를 관리하는 프로세스입니다.-는 일반적으로 디버깅 할 필요가 없습니다. 첫 번째 워커의 디버그 포트는 지정된 포트 + 1이고 그 뒤론 +1씩 증가합니다.
// workerCluster 프로세스는 포트 5999에서 디버깅할 수 있습니다.
// 첫 번째 워커는 포트 6000에서 디버깅 할 수 있습니다.
node server --debug-workers=5999
이는 브로커에도 적용됩니다:
// 첫 번째 브로커는 포트 5999에서 디버깅할 수 있습니다.
node server --debug-brokers=5999
Node.js v6.3.0 이상을 사용하는 경우 위의 'debug'키워드를 'inspect'로 대체하면 본질적으로 동일한 방식으로 작동합니다. 디버거 URL이 콘솔에 표시되는지 확인해야 합니다. 그냥 복사해서 브라우저에 붙여 넣기만 하면 됩니다.

마스터 프로세스(server.js)를 디버그하려면 일반적인 방식으로 하면 됩니다.
node --debug-brk server
혹은 Node.js >= v6.3.0이라면:
node --inspect server
^이 경우에도 순서가 중요합니다. (이번에는 --debug-brk 또는 --inspect가 서버 인수보다 에 있어야합니다!)

워커를 디버깅 할 때 가끔 특정 행에서 중단시키거나 계속 진행할 하고자 할 것입니다.(유휴 상태, 연결 대기 중). 이렇게 하려면 worker.js 코드에서 당신이 멈추고자하는 곳에 debugger; 명령을 추가해야합니다.

워커의 경우 전역 worker 객체(디버거 콘솔에서)에 접근할 수 있으므로 서버와 상호 작용하고 worker.exchange.publish( 'pong', 'This is a message for the pong channel')를 워커로부터 당신의 다른 시스템과 상호작용. (이 기능에 액세스하려면 코드의 아무 곳이나 debugger 문을 추가할 필요가 없습니다. 워커 변수는 모든 범위에서 액세스 할 수 있도록 전역에 노출됩니다.)

마찬가지로 브로커 프로세스를 디버깅 할 때 브로커 객체에 액세스 할 수 있으며 작업자와 마찬가지로 디버거를 통해 브로커와 직접 상호 작용할 수 있습니다.

주제를 조금 벗어나 : 여러 브로커를 사용하는 경우 각 브로커는 사용 가능한 모든 채널의 하위 집합만 관리합니다 (SC의 확장성에 대한 비밀스런 소스입니다). 따라서 브로커에게 publish()하면 아무도 메시지를 받지 못합니다. 특정 채널을 담당하는 브로커에서 publish()를 호출해야합니다.

2016년 12월 10일 토요일

탄력받은 김에 socketcluster 호스팅 서비스인 baasil.io 도 써보았다.

한달 무료 플랜이 있어서 광속가입.
나는야 시스템 어드민이기 때문에 유저따윈 얼마든지 만들 수 있다.

철자가 좀 헷깔린다. baasil.io다. 다소 웹페이지가 엉성한 느낌은 있다.
이런건 망하기 전에 잽싸게 빨대 꽂는 것이 인지상정.

아마도 대부분 유료를 겁내고 자신의 계정이 한달짜리 트라이얼로 소모되는게 아까우실거라고 생각하여 대신 가입해봄 -_-)v

가입 후 Email validation을 하고 나면
어서와. 소켓클러스터는 처음이지?

매우매우매우 심플하다.
Baasil.io manages your real-time infrastructure for you without compromising on flexibility. We provide you with a highly scalable, open source boilerplate (SCC) which you can modify as you like and then deploy to your own Kubernetes environment/cluster using a single command. The boilerplate we provide is designed to scale seamlessly across up to 1000 machines/hosts.
For the standard plan, Baasil.io gives you an isolated environment on a shared Rancher control panel. This setup is ideal if you have a relatively small number of machines (e.g. 1 to 20 hosts in your cluster) and are happy to look after your cluster using Rancher. If you would like to support more than 20 machines, want a completely hands-off experience when it comes to your infrastructure, or want your own dedicated Rancher control panel - We can make it happen with our flexible enterprise plan. If you would like to updgrade to the enterprise plan, you can contact us here.
You need to link your Baasil.io account to a valid GitHub account here before you can create your Rancher environment/cluster.
라고 한다.
Rancher라는 걸 쓰려면 깃허브 계정과 연동하라고 하는데 일단 패스
Try It을 보니
서비스키!! 키를 내놓으라!

오호. 서비스 키라는 걸 제공. 클라이언트 사이드에서 사용할 수 있다.
근데 크롬에서 개발자 콘솔 여는 단축키는 Cmd + Shift + J on OSX 아니야. Cmd + Option + J 라구!
<script src="https://baasil.io/socketcluster.js"></script>
요렇게 클라이언트에 붙이고
var socket = socketCluster.connect({
    query: {
      serviceKey: '섭수키:main'
    },
    channelPrefix: '섭수키:main#',
    hostname: 'service.baasil.io',
    port: 443,
    secure: true
  });
이렇게 접속해서

Subscribe
var myChannel = socket.subscribe('my-channel-name');
Watch
myChannel.watch(function (data) {
    // Handle incoming channel data here. You can set up multiple watchers per channel.
    console.log('myChannel data:', data);
  });
Unwatch
// The handler argument is optional (a function) - If not provided, it will unbind all watchers.
  myChannel.unwatch(handler);
Publish
myChannel.publish({foo: 'This is some JSON data'}, function (err) {
    // Callback to indicate whether or not publish was successful.
  });
Unsubscribe

myChannel.unsubscribe();
Check channel subscription state

myChannel.state // Can be 'unsubscribed', 'subscribed' or 'pending'
Check socket connection state
socket.state // Can be 'open', 'connecting' or 'closed'
Other useful operations...
Get array of watchers
// Get array of functions which are watching that channel.
  myChannel.watchers();
Subscribe again...
// Subscribe to a channel which was previously unsubscribed.
  myChannel.subscribe();
Get channel reference from socket
// This will not create any new subscriptions - Just get a channel reference.
  var myChannel = socket.channel('my-channel-name');
Get list of all subscribed channels
// Returns an array of channel names which are currently subscribed.
  // If the second argument is true, it will include channels which are pending subscription.
  socket.subscriptions('my-channel-name', true);
꿀팁을 마구 대방출.
뭐 이것만 알면 되겠네.
세상 참 좋구만.

그 다음은 https://docs.baasil.io/ 를 보고 CLI 도 설치해본다.
npm install -g baasil
설치 끗.
하나 만들어 봐야지. 그전에 docker가 있어야 하니 꼭 체크하고.
baasil create jwaujijangjiji 
해보니
Creating app structure...
[Success] Baasil.io app '/Users/spectrum/Documents/js/_app/jwaujijangjiji' was setup successfully.
끗.
node.js 가 그렇지 뭐;
실행해보자.
$ cd jwaujijangjiji
$ baasil run
Unable to find image 'socketcluster/socketcluster:v5.1.2' locally
v5.1.2: Pulling from socketcluster/socketcluster
5c90d4a2d1a8: Pull complete
ab30c63719b1: Pull complete
29d0bc1e8c52: Pull complete
f222342d2902: Pull complete
27808f091869: Pull complete
a5f3825caa0a: Pull complete
Digest: sha256:d466ab21339117e03aad3f97583cdb3320a4520f3d515f8dd6c1bfd19dba1c75
Status: Downloaded newer image for socketcluster/socketcluster:v5.1.2
2c597396d46e4c60348b5abfea8bc95bf099b1be0f9c9313c21859ff386d481e
[Success] App 'baasil01' is running at http://localhost:8000
docker 리파지터리에서 socketcluster 이미지를 땡겨온 다음 8000로 실행한다.
아주 좋아!
baasil --help
Usage: baasil [options] [command]
Options:
  -v            Get the version of the current Baasil.io installation
  --help        Get info on how to use this command
  --force       Force all necessary directory modifications without prompts
Commands:
  create <app-name>             Create a new boilerplate SCC app in working directory
  run <path>                    Run app at path inside container on your local machine
  restart <app-path-or-name>    Restart an app with the specified name
  stop <app-path-or-name>       Stop an app with the specified name
  list                          List all running Docker containers on your local machine
  logs <app-path-or-name>       Get logs for the app with the specified name
  deploy <app-path>             Deploy app at path to your Baasil.io cluster
  deploy-update <app-path>      Deploy update to app which was previously deployed
  undeploy <app-path>           Shutdown all core app services running on your cluster
맨드 라인 내용을 보니 대략 이렇다.
필요한 것만 딱 들어있네.
공통인 부분은 죄다 제외하고 서버 사이드엔 worker.js 와 package.json 나머지 client는 public안에 다 몰아놓았다.
안그래도 간단한데 더욱 간단하다.
docker와 kurbernate가 세상을 정말 많이 바꿨구나. 이젠 이런게 아무렇지도 않군.

다짜고짜 deploy 때려보자.
dockerhub 계정을 요구한다.
만들어만들어~
$ baasil deploy
? Enter your DockerHub username: bsio20161210
? Enter your DockerHub password: *********
? Enter the number of workers for each SocketCluster instance (Default: 1): 4
? Enter the number of brokers for each SocketCluster instance (Default: 1):
? Enter the Docker image name without the version tag (Or press enter for default: bsio20161210/
baasil01):
? Enter the Docker version tag for this deployment (Default: v1.0.0):
Sending build context to Docker daemon 228.9 kB
Step 1 : FROM node:6.3.0-slim
6.3.0-slim: Pulling from library/node

worker는 4개!
[Error] Failed to deploy the 'baasil01' app. Command failed: kubectl create -f /Users/spectrum/Documents/js/_app/csjBootstrap/baasil01/kubernetes/scc-broker-deployment.yaml
실패한다.
쩝, github 연동 먼저 해야지.

https://baasil.io/#!/dashboard?main-tab=account 에서 github account 넣어주고
https://baasil.io/#!/dashboard?main-tab=infrastructure 로 돌아오면 Rancher 생성이 활성화 된다.

TADA!
지금부터 대쉬보드인가!
생성생성

좋다. host 생성하자.
이것저것 눌러보자. 음... 잘만들었네.
EC2나 Azure는 쓰지 않는다. Custom으로 ㄱ

잘모르니까 디폴트.
5번에 Copy, paste, and run the command below to register the host with Rancher: 부분 아래에 있는 명령을 복사해서 터미널에 붙여넣자.

Unable to find image 'rancher/agent:v1.0.2' locally
v1.0.2: Pulling from rancher/agent
5a132a7e7af1: Pull complete 
fd2731e4c50c: Pull complete 
28a2f68d1120: Pull complete 
a3ed95caeb02: Pull complete 
7fa4fac65171: Pull complete 
33de63de5fdb: Pull complete 
d00b3b942272: Pull complete 
Digest: sha256:b0b532d1e891534779d0eb1a01a5717ebfff9ac024db4412ead87d834ba92544
Status: Downloaded newer image for rancher/agent:v1.0.2
5cc13082b79f9b58a488c456fdd1500de6b7f9450bd6ab42aa89517088c61336
docker: Error response from daemon: Mounts denied: 
The path /var/lib/rancher
is not shared from OS X and is not known to Docker.
You can configure shared paths from Docker -> Preferences... -> File Sharing.
See https://docs.docker.com/docker-for-mac/osxfs/#namespaces for more info.
..
오류가 나는데
sudo docker run -d --privileged -v /var/run/docker.sock:/var/run/docker.sock -v /var/lib/rancher:/var/lib/rancher rancher/agent:v1.0.2 https://localhost:8000/v1/scripts/ㅌㅌㅌㅌㅌㅌㅌㅌㅌㅌㅌㅌㅌㅌㅌ:ㅌㅌㅌㅌㅌㅌㅌㅌㅌㅌㅌㅌㅌ
ㅉㅉㅉㅉㅉㅉㅉㅉㅉㅉㅉㅉㅉㅉㅉㅉㅈ
이런식으로 주소를 localhost기준으로 바꿔주자. 디폴트는 8000번 포트.

아으 여기까지 해봤는데 지친다.
local로만 해보고 이미지 떠서 다른데 호스팅 하는게 낫겠어. 귀찮네.

#짐싸자


socketcluster tutorial - 3. 기본 사용법 (Basic usage)

기본 사용법

본 튜토리얼을 진행하기 전에 '시작하기'를 읽어 보아야 합니다.

일단 SocketCluster를 설정하면 server.js라는 JavaScript 파일이 만들어집니다.
// Server code
var SocketCluster = require('socketcluster').SocketCluster;
var socketCluster = new SocketCluster({
  workers: 1,
  brokers: 1,
  port: 8000,
  appName: 'app',
  // 주요 성능 향상을 위해 wsEngine을 'uws'로 전환하세요.
  wsEngine: 'ws',
  workerController: __dirname + '/worker.js',
  brokerController: __dirname + '/broker.js',
  socketChannelLimit: 1000,
  rebootWorkerOnCrash: true
});
이러한 옵션 중 일부를 이해하려면 SocketCluster가 서버에서 3가지 다른 종류의 프로세스 클러스터로 실행되는 것을 고려해야합니다.

마스터 프로세스 (server.js)


모든 것이 시작되는 곳입니다.

Workers


이것은 모든 비즈니스 로직이 있어야하는 곳입니다 - workerController는 실시간 소켓 연결 및 이벤트를 처리하기 위해 HTTP 서버 및 실시간 SocketClusterServer에 대한 로직을 설정할 수 있습니다.

Brokers


이것은 주로 SocketCluster 내부적에서 사용하며 모든 작업자가 서로 효율적으로 이벤트를 공유 할 수 있게합니다. 또한 이 데이터를 사용하여 세션 데이터를 저장하고 여러 대의 컴퓨터에서 수평적으로 응용 프로그램을 확장 할 수도 있습니다.

보일러플레이트 앱


workerController 파일 (worker.js)을 열면 httpServer와 scServer가 요청/연결을 수락하는 코드가 보입니다. 기본적으로 httpServer는 public/folder의 내용을 제공하는 Express(정적 서버 미들웨어 포함) 모듈에 연결됩니다:
// Server code
app.use(serveStatic(__dirname + '/public'));
httpServer.on('req', app);
보일러플레이트 앱에선 scServer는 들어오는 WebSocket 연결을 처리하고 클라이언트 소켓에서 사용자 정의 'ping'이벤트를 수신합니다 (다른 것들 중에서도):
// Server code
var count = 0;
scServer.on('connection', function (socket) {
  // ...
  socket.on('ping', function (data) {
    count++;
    console.log('PING', data);
    scServer.exchange.publish('pong', count);
  });
});

여기에서 'ping'이벤트는 클라이언트 소켓이 다음을 사용하여 클라이언트에서 ping을 내보낼 때마다 트리거됩니다.
// Client code
socket.emit('ping', 'This is a PING message')
이벤트를 보내는 것은 클라이언트와 서버간에 메시지를 전달하는 가장 간단한 방법이지만 메시지를 공유하는 유일한 방법은 아닙니다.

이 목록의 예약된 이벤트 이름을 제외하고 원하는대로 이벤트의 이름을 지정할 수 있습니다. 이는 SC 내에서 특별한 의미가 있습니다. 시스템에 많은 이벤트가있는 경우, 이벤트 이름을 지정하는 좋은 규칙은 '.'기호를 사용하는 것입니다. 형식은 'myNamespace.myEvent'입니다.

채널에 데이터를 발행할 수도 있습니다. 채널에 발행하면 한 번에 여러 클라이언트에 데이터를 보낼 수 있습니다. 채널에 등록된 클라이언트는 해당 채널에 발행한 모든 데이터를 수신합니다. 클라이언트와 서버 모두 채널에 발행할 수 있습니다 (미들웨어로 인해 채널이 차단되지 않는 경우). 채널은 주로 클라이언트와 클라이언트 간의 통신을 위한 것이지만 SC는 서버의 채널을 청취하는 방법을 제공합니다 (이 주제는 다른 튜토리얼에서 더 자세한 내용을 다룹니다).

위의 서버 측 코드 조각 하나는 다음과 같이 'pong'채널에 발행하고 있습니다.

// Server code
scServer.exchange.publish('pong', count);
SocketCluster에 연결되어 있고 'pong'채널을 구독하고 있는 클라이언트는 count 변수의 값을 받습니다. 클라이언트에서 코드는 다음과 같습니다.
// Client code
// New API as of SocketCluster v1.0.0.
var pongChannel = socket.subscribe('pong');
pongChannel.watch(function (count) {
  console.log('Client received data from pong channel:', count);
});
하나 이상의 채널을 구독 취소하려면 다음 단계를 따릅니다:
// Client code
socket.unsubscribe('pong');
앞서 설명한 것처럼 scServer.exchange.publish (...)를 사용하여 서버에서 채널에 발행할 수 있습니다. 편의를 위해 SocketCluster를 사용하면 클라이언트측에서 채널에 발행할 수도 있습니다:
// Client code
socket.publish('pong', 'This PONG event comes from a client');
여기서 문자열을 인수로 전달합니다. 채널 개체에 직접 데이터를 발행할 수도 있습니다. 다음 코드는 위와 똑같은 작업을 수행합니다:
// Client code
pongChannel.publish('This PONG event comes from a client');
때로는 특정 개인의 특정 채널에 대한 읽기 또는 쓰기 권한을 제한할 수 있습니다. 이러한 목적으로 SC를 사용하려면 미들웨어 기능을 활용하세요. 이에 대해 자세히 알아 보려면 "미들웨어와 권한" 가이드를 읽어보세요.

요약


socket.emit (event, data) 함수를 사용하면 클라이언트 소켓 1 개와 일치하는 서버 소켓 1 개 (클라이언트 소켓 1 개⇄서버 소켓 1 개—클라이언트와 서버간 1대1 통신)간에 메시지를 보낼 수 있습니다.

socket.publish (event, data) 및 channel.publish (data) 함수를 사용하면 여러 클라이언트 소켓 (n 개의 클라이언트 소켓 ⇄ n 클라이언트 소켓 - 클라이언트 간의 직접 통신)을 통해 그룹 메시지를 보낼 수 있습니다. 앞에서 설명한 것처럼 교환 객체를 사용하여 서버에서 발행을 호출 할 수도 있습니다.
// Server code
scServer.exchange.publish('foo', 123);
두 클라이언트 사이의 일대일 통신을 위해 게시를 사용할 수도 있지만 두개의 승인된 클라이언트만 동일한 채널을 공유할 수 있도록 특정 미들웨어를 설정해야합니다. 자세한 내용은 "미들웨어와 권한" 가이드를 참조하십시오.

비디오 Nick Kotenberg


007 Socketcluster Server/Client Communication Basic
008 Server/Client Data 1
009 Server/Client Data 2
010 Databases and SC 101
011 Server to Server Communication

socketcluster tutorial - 2. 시작하기 (Getting Started)

시작하기


SocketCluster를 시작하려면 Node.js가 설치되어 있어야 합니다. 이 지침에 따라 NodeJS를 설치할 수 있습니다. 또는 Baasil.io로 Docker 컨테이너에서 SocketCluster를 실행할 수 있습니다. - Kubernetes 환경에 앱을 배포하려는 경우 이상적입니다 - 여기를 참조하십시오.

Node가 설치되면 SocketCluster를 설치할 수 있습니다. SocketCluster를 설치하는 두 가지 방법이 있습니다. 가장 간단한 방법 프레임워크로 설치할 수 있고 보다 구체적인 요구 사항이있는 경우 클라이언트와 서버를 따로 설치할 수도 있습니다. 두 설정은 거의 동일한 API를 공유하므로 일반적으로 전환할 때 코드를 변경할 필요가 없습니다. 사실, socketcluster-server는 socketcluster (프레임 워크)의 직접적으로 종속됩니다.

SocketCluster를 독립 실행형 서버 및 클라이언트로 설치하려면 다음을 수행하십시오. 여기(서버)여기(클라이언트)의 지침을 따르십시오.

프레임워크로 설치하려면 (권장) :
npm install -g socketcluster
일단 설치되면, socketcluster create 명령은 새로운 SocketCluster 를 설치합니다. 예를 들어, socketcluster create myApp는 현재 작업 디렉토리에 myApp라는 디렉토리를 작성합니다.
socketcluster create myApp
번들된 패키지(webpack같은)에서 사용하려면
npm install --save socketcluster
npm install --save socketcluster-client
하고 서버에서
var SocketCluster = require('socketcluster').SocketCluster
그리고 클라이언트에서
var SocketCluster = require('socketcluster-client')
를 추가합니다.

SocketCluster 서버 프로그래밍


이 작업을 마치면 myApp으로 이동하여 node server.js를 사용하여 즉시 서버를 실행할 수 있습니다
node server.js
브라우저에서 http://localhost:8000/ 으로 이동하여 서버에 연결할 수 있습니다.

SocketCluster의 실시간 기능을 테스트하려면 브라우저의 개발자 콘솔을 열고 다음과 같이 입력하십시오:
// Client side
var socket = socketCluster.connect();
socket.emit('sampleClientEvent', {message: 'This is an object with a message property'});
'Sample channel message: 1' 메시지가 다시 나타납니다. - 서버는 sampleClientEvent 이벤트를 수신 한 다음 샘플 이벤트를 청취중인 모든 클라이언트에 게시합니다.

emit 및 publish 명령의 두 번째 인수로 JSON과 호환되는 거의 모든 것을 전달할 수 있습니다.

클라이언트 측의 socketCluster.connect () 메소드에 object형인 옵션을 사용할 수 있습니다. 자세한 내용은 socketCluster를 참조하십시오. 주요 SocketCluster JavaScript 클라이언트에 대한 자세한 내용을 보려면 여기를 클릭하십시오.

서버 측에서는 server.js 내의 코드를 편집하여 SocketCluster를 구성 할 수 있습니다. SocketCluster는 30가지 이상의 옵션을 제공하며 사용자의 특정 요구에 맞게 변경할 수 있습니다 (대부분 옵션은 선택 사항 입니다).

다음은 server.js 파일의 예제입니다 (주석 포함):
var SocketCluster = require('socketcluster').SocketCluster;
var socketCluster = new SocketCluster({
  workers: 1, // worker processes의 갯수
  brokers: 1, // broker processes의 갯수
  port: 8000, // 서버가 여는 포트 번호
  appName: 'myapp', // 고유한 앱 이름
  // 주요 성능 향상을 위해 wsEngine을 'ws'를 'uws'로 전환하세요
  wsEngine: 'ws',
  /* 워커/서버를 구성하는 JS 파일
   * 여기서 대부분의 백엔드 코드를 작성합니다.
   */
  workerController: __dirname + '/worker.js',
  /* 각각의 브로커들을 구성하는 JS 파일
   * 여러 시스템에서 수평으로 확장하는 데 유용합니다 (선택 사항).
   */
  brokerController: __dirname + '/broker.js',
  // 워커가 죽을 경우 재시작할지 여부 (기본값은 true)
  rebootWorkerOnCrash: true
});
SocketCluster는 여러 개의 프로세스 클러스터를 실행합니다. 각 프로세스에는 각 프로세스의 동작을 구성 할 수있는 자체 '컨트롤러'파일이 있습니다. 로드 밸런서용 컨트롤러, 워커용 컨트롤러 및 브로커 프로세스 용 컨트롤러가 있습니다. 가장 중요한 것은 (대부분의 응용 프로그램을 작성하는) workerController입니다.

그리고 그 다음


workerController (worker.js)에 있는 기존 코드를 살펴보고 만져보세요.

코드를 변경할 때 SocketCluster를 다시 시작하십시오. UNIX와 유사한 환경에서 실행중이라면 SIGUSR2 신호를 마스터 PID 순서로 보내어 새로운 소스 코드로 오직 워커들만 재시작할 수도 있습니다.

Nick Kotenberg의 비디오

socketcluster tutorial - 1. 소개 Introduction

소개

SocketCluster는 빠르고 확장성이 뛰어난 HTTP + WebSockets 서버 환경으로, 시스템/인스턴스의 모든 CPU 코어를 사용하는 다중 프로세스 실시간 시스템을 구축할 수 있습니다.
Node.js 서버를 단일 스레드로 실행해야하는 한계를 없애고 worker 충돌에서 자동으로 복구하여 백엔드를 복원합니며. 오류도 중앙 로그로 모아줍니다.

SocketCluster는 Docker 컨테이너의 Kubernetes에서 실행되도록 최적화되어 있습니다 (자세한 내용은 SCC 참조).

SocketCluster는 pub/sub시스템(브라우저 / IoT 장치까지)과 같이 작동합니다. - 실제로 필요한 특정 이벤트를 클라이언트에게 전달합니다. SC는 수직으로 (프로세스의 클러스터로서) 수평적으로 (여러 머신 / 인스턴스) 모두 확장 할 수 있도록 설계하였습니다.

SC는 모듈 구조로 설계하였으므로 express와 같은 다른 프레임 워크 위(또는 자신 만의 빌드!)에서 동작가능합니다. SC의 실시간 API는 Socket.io의 API와 비슷합니다.

SocketCluster를 독립형 프레임 워크(HTTP 및 WebSocket 서버로 작동)로 사용하거나 실시간 엔진으로 만 사용하고 클라이언트 스크립트를 별도로 제공할 수 있습니다. http://npmjs.org/socketcluster-client를 참조하십시오.

Twitter를 팔로우하세요. http://socketcluster.launchrock.com/ 에서 업데이트를 구독하세요.

이 사이트는 오픈 소스이기도 하며 Github 참여를 환영합니다.

게임에서


SC는 멀티 플레이어 온라인 게임 제작에 이상적입니다. Phaser 데모를 보십시오. 대역폭 소비를 줄이려면 sc-codec-min-bin과 함께 SC를 사용하는 것이 좋습니다. 이 코덱은 SC 메시지를 압축하여 유선을 통해 전송 될 때 이진 패킷으로 변환합니다. 또는 특정 게임/응용 프로그램에 최적화 된 자신만의 코덱을 작성할 수도 있습니다.

메모리 누출 프로파일


SC는 메모리 누수 여부를 테스트 하였습니다. 마지막 전체 메모리 프로파일 링은 v0.9.17 (Node.js v0.10.28)에서 수행되었으며 작업자 및 브로커 프로세스에 대한 검사가 포함되었습니다. 메모리 누수가 발견되지 않았습니다.

주요 공여자


Jonathan Gros-Dubois
Matt Krick
Alex Hultman
Anatoliy Popov
Sachin Shinde
Nick Kotenberg
Rob Borden
Nelson Zheng
Lihan Li
MegaGM
wactbprot

socketcluster 를 써보았다. 아주 좋았다.

일단 worker.js에
  scServer.on('connection', function (client) {
    console.log(`${client.id} is connected`);
  });
그리고 client쪽은
var socket = socketCluster.connect();
socket.on('error', function (err) {
  throw 'Socket error - ' + err;
});
socket.on('connect', function () {
  console.log('CONNECTED');
});
이쯤에서 시작해보자.
클라이언트가 시작하면 서버쪽에선 client.id 가 발급되는 것을 볼 수 있다.
QVmNv2hblXhynoXOAAAE is connected
아마 이런 식으로 응답할 것이다.

DDP처럼 RPC 와 Pub/Sub을 해보자.

먼저 단순 호출+응답 형태를 구현해보자.
서버는 socket.on('connect', ...); 가 다음에 이렇게 
    socket.on('message.send', function (data) {
      console.log(data);
    });
클라이언트에선 그저 크롬 창 열고
socket.emit('message.send', { message: 'PING' });
해보자.

서버쪽에서 PING 찍히면 오케이.
이 메시지를 Pub/Sub으로 해보자.
서버쪽 구현을 변경하자.
    socket.on('message.send', function (data) {
      console.log('message.send', data);
      scServer.exchange.publish('message.publish', {
        from: socket.id,
        message: data
      });
    });
클라이언트도 맞춰서 message.publish를 subscribe 하는 부분을 추가해보자.
var messageChannel = socket.subscribe('message.publish');
messageChannel.watch(function(data) {
  console.log('message', data);
});
하. 뭐지? 너무 좋쟎아? 멀티유저도 그냥 되네?
RxDDP Server보다 이걸 먼저 만들어야겠다.

https://gomix.com/#!/project/sc-chat
gomix에 아주 간단한 채팅 앱을 pub/sub을 써서 만들어보았다. 참조.

2016년 12월 8일 목요일

Chrome source map 먼지팁 (coffeescript/typescript/babel)

잘 되다가 갑자기 coffeescript/typescript/babel 등등의 디버깅이 sourcemap 연결 안된다면
크롬 디버거 열고 F1 누르고 Settings > Preferences > Sources > Enable Javascript source maps 를 체크해준다.


그러고 다시 크롬 디버거를 열어보면 Sources 탭에
요렇게 예쁘게 나온다.
갑자기 설정이 풀렸다 싶으면 당황하지 말고 Settings를 확인해보자.