自己搭建的ngrok服务器如何添加身份验证

虽然成功搭建了ngrok服务器,本地能被访问
但有几个问题:
1. 没有设置密码账号,谁都可以用
2. 尝试连接ngrok.com会连接成功,但立即提示需要付费
3. 怎样给ngrokd服务端添加身份验证

纯粹是问问,分不多

控制台输出

服务端参数

 >ngrokd -help
Usage of ngrokd:
  -domain string
        Domain where the tunnels are hosted (default "ngrok.com")
  -httpAddr string
        Public address for HTTP connections, empty string to disable (default ":80")
  -httpsAddr string
        Public address listening for HTTPS connections, emptry string to disable (default ":443")
  -log string
        Write log messages to this file. 'stdout' and 'none' have special meanings (default "stdout")
  -log-level string
        The level of messages to log. One of: DEBUG, INFO, WARNING, ERROR (default "DEBUG")
  -tlsCrt string
        Path to a TLS certificate file
  -tlsKey string
        Path to a TLS key file
  -tunnelAddr string
        Public address listening for ngrok client (default ":4443")

客户端参数

 >ngrok -help
Usage: ngrok [OPTIONS] <local port or address>
Options:
  -authtoken string
        Authentication token for identifying an ngrok.com account
  -config string
        Path to ngrok configuration file. (default: $HOME/.ngrok)
  -hostname string
        Request a custom hostname from the ngrok server. (HTTP only) (requires CNAME of your DNS)
  -httpauth string
        username:password HTTP basic auth creds protecting the public tunnel endpoint
  -log string
        Write log messages to this file. 'stdout' and 'none' have special meanings (default "none")
  -log-level string
        The level of messages to log. One of: DEBUG, INFO, WARNING, ERROR (default "DEBUG")
  -proto string
        The protocol of the traffic over the tunnel {'http', 'https', 'tcp'} (default: 'http+https') (default "http+https")
  -subdomain string
        Request a custom subdomain from the ngrok server. (HTTP only)

参数倒是意味着 客户端可以发送身份验证信息启动
服务端....没有参数指定谁来处理这个验证消息
该不会要我去学狗浪吧(ˉ▽ ̄~) 切~~

0

3个回答

0
wang845252276
很倔也很天真 按因果关系,你也算是解决问题的一个因
大约一年之前 回复
dabocaiqq
请你们大家多多姿瓷我菠菜菌 回复wang845252276: 可以举一反三的
大约一年之前 回复
wang845252276
很倔也很天真 已经打通了隧道 , 现在需要加密
大约一年之前 回复

真是频频遇到百度不能解决的问题,貌似很多程序员将解决方法放到了更大的互联网圈子,例如国外
在百度没搜到,但在必应国际版就找到了想要的结果了

犹如出了新手村寻找世界的真谛一般

解决方案如下

  • 修改ngrok源代码,当然 我没有深究其他解决方案,因为我对golang不太了解

参考地址 : server端增加authtoken验证支持

为了防止地址失效粘贴下:

 package server

import (
    "fmt"
    "io"
    "ngrok/conn"
    "ngrok/msg"
    "ngrok/util"
    "ngrok/version"
    "runtime/debug"
    "strings"
    "time"
    "os"
    "bufio"
)

const (
    pingTimeoutInterval = 30 * time.Second
    connReapInterval = 10 * time.Second
    controlWriteTimeout = 10 * time.Second
    proxyStaleDuration = 60 * time.Second
    proxyMaxPoolSize = 10
)

type Control struct {
    // auth message
    auth            *msg.Auth

    // actual connection
    conn            conn.Conn

    // put a message in this channel to send it over
    // conn to the client
    out             chan (msg.Message)

    // read from this channel to get the next message sent
    // to us over conn by the client
    in              chan (msg.Message)

    // the last time we received a ping from the client - for heartbeats
    lastPing        time.Time

    // all of the tunnels this control connection handles
    tunnels         []*Tunnel

    // proxy connections
    proxies         chan conn.Conn

    // identifier
    id              string

    // synchronizer for controlled shutdown of writer()
    writerShutdown  *util.Shutdown

    // synchronizer for controlled shutdown of reader()
    readerShutdown  *util.Shutdown

    // synchronizer for controlled shutdown of manager()
    managerShutdown *util.Shutdown

    // synchronizer for controller shutdown of entire Control
    shutdown        *util.Shutdown
}

func NewControl(ctlConn conn.Conn, authMsg *msg.Auth) {
    var err error

    // create the object
    c := &Control{
        auth:            authMsg,
        conn:            ctlConn,
        out:             make(chan msg.Message),
        in:              make(chan msg.Message),
        proxies:         make(chan conn.Conn, 10),
        lastPing:        time.Now(),
        writerShutdown:  util.NewShutdown(),
        readerShutdown:  util.NewShutdown(),
        managerShutdown: util.NewShutdown(),
        shutdown:        util.NewShutdown(),
    }

    failAuth := func(e error) {
        _ = msg.WriteMsg(ctlConn, &msg.AuthResp{Error: e.Error()})
        ctlConn.Close()
    }
    readLine := func(token string, filename string) (bool, error) {

        if token == "" {
            return false, nil;
        }
        f, err := os.Open(filename)
        if err != nil {
            return false, err
        }
        buf := bufio.NewReader(f)
        for {
            line, err := buf.ReadString('\n')
            line = strings.TrimSpace(line)
            if line == token {
                return true, nil
            }
            if err != nil {
                if err == io.EOF {
                    return false, nil
                }
                return false, err
            }
        }
        return false, nil
    }
    // register the clientid
    c.id = authMsg.ClientId
    if c.id == "" {
        // it's a new session, assign an ID
        if c.id, err = util.SecureRandId(16); err != nil {
            failAuth(err)
            return
        }
    }

    // set logging prefix
    ctlConn.SetType("ctl")
    ctlConn.AddLogPrefix(c.id)

    if authMsg.Version != version.Proto {
        failAuth(fmt.Errorf("Incompatible versions. Server %s, client %s. Download a new version at http://ngrok.com", version.MajorMinor(), authMsg.Version))
        return
    }
    authd, err := readLine(authMsg.User, "authtokens.txt")

    if authd != true {
        failAuth(fmt.Errorf("authtoken %s invalid", "is"));
        return
    }

    // register the control
    if replaced := controlRegistry.Add(c.id, c); replaced != nil {
        replaced.shutdown.WaitComplete()
    }

    // start the writer first so that the following messages get sent
    go c.writer()

    // Respond to authentication
    c.out <- &msg.AuthResp{
        Version:   version.Proto,
        MmVersion: version.MajorMinor(),
        ClientId:  c.id,
    }

    // As a performance optimization, ask for a proxy connection up front
    c.out <- &msg.ReqProxy{}

    // manage the connection
    go c.manager()
    go c.reader()
    go c.stopper()
}

// Register a new tunnel on this control connection
func (c *Control) registerTunnel(rawTunnelReq *msg.ReqTunnel) {
    for _, proto := range strings.Split(rawTunnelReq.Protocol, "+") {
        tunnelReq := *rawTunnelReq
        tunnelReq.Protocol = proto

        c.conn.Debug("Registering new tunnel")
        t, err := NewTunnel(&tunnelReq, c)
        if err != nil {
            c.out <- &msg.NewTunnel{Error: err.Error()}
            if len(c.tunnels) == 0 {
                c.shutdown.Begin()
            }

            // we're done
            return
        }

        // add it to the list of tunnels
        c.tunnels = append(c.tunnels, t)

        // acknowledge success
        c.out <- &msg.NewTunnel{
            Url:      t.url,
            Protocol: proto,
            ReqId:    rawTunnelReq.ReqId,
        }

        rawTunnelReq.Hostname = strings.Replace(t.url, proto + "://", "", 1)
    }
}

func (c *Control) manager() {
    // don't crash on panics
    defer func() {
        if err := recover(); err != nil {
            c.conn.Info("Control::manager failed with error %v: %s", err, debug.Stack())
        }
    }()

    // kill everything if the control manager stops
    defer c.shutdown.Begin()

    // notify that manager() has shutdown
    defer c.managerShutdown.Complete()

    // reaping timer for detecting heartbeat failure
    reap := time.NewTicker(connReapInterval)
    defer reap.Stop()

    for {
        select {
        case <-reap.C:
            if time.Since(c.lastPing) > pingTimeoutInterval {
                c.conn.Info("Lost heartbeat")
                c.shutdown.Begin()
            }

        case mRaw, ok := <-c.in:
        // c.in closes to indicate shutdown
            if !ok {
                return
            }

            switch m := mRaw.(type) {
            case *msg.ReqTunnel:
                c.registerTunnel(m)

            case *msg.Ping:
                c.lastPing = time.Now()
                c.out <- &msg.Pong{}
            }
        }
    }
}

func (c *Control) writer() {
    defer func() {
        if err := recover(); err != nil {
            c.conn.Info("Control::writer failed with error %v: %s", err, debug.Stack())
        }
    }()

    // kill everything if the writer() stops
    defer c.shutdown.Begin()

    // notify that we've flushed all messages
    defer c.writerShutdown.Complete()

    // write messages to the control channel
    for m := range c.out {
        c.conn.SetWriteDeadline(time.Now().Add(controlWriteTimeout))
        if err := msg.WriteMsg(c.conn, m); err != nil {
            panic(err)
        }
    }
}

func (c *Control) reader() {
    defer func() {
        if err := recover(); err != nil {
            c.conn.Warn("Control::reader failed with error %v: %s", err, debug.Stack())
        }
    }()

    // kill everything if the reader stops
    defer c.shutdown.Begin()

    // notify that we're done
    defer c.readerShutdown.Complete()

    // read messages from the control channel
    for {
        if msg, err := msg.ReadMsg(c.conn); err != nil {
            if err == io.EOF {
                c.conn.Info("EOF")
                return
            } else {
                panic(err)
            }
        } else {
            // this can also panic during shutdown
            c.in <- msg
        }
    }
}

func (c *Control) stopper() {
    defer func() {
        if r := recover(); r != nil {
            c.conn.Error("Failed to shut down control: %v", r)
        }
    }()

    // wait until we're instructed to shutdown
    c.shutdown.WaitBegin()

    // remove ourself from the control registry
    controlRegistry.Del(c.id)

    // shutdown manager() so that we have no more work to do
    close(c.in)
    c.managerShutdown.WaitComplete()

    // shutdown writer()
    close(c.out)
    c.writerShutdown.WaitComplete()

    // close connection fully
    c.conn.Close()

    // shutdown all of the tunnels
    for _, t := range c.tunnels {
        t.Shutdown()
    }

    // shutdown all of the proxy connections
    close(c.proxies)
    for p := range c.proxies {
        p.Close()
    }

    c.shutdown.Complete()
    c.conn.Info("Shutdown complete")
}

func (c *Control) RegisterProxy(conn conn.Conn) {
    conn.AddLogPrefix(c.id)

    conn.SetDeadline(time.Now().Add(proxyStaleDuration))
    select {
    case c.proxies <- conn:
        conn.Info("Registered")
    default:
        conn.Info("Proxies buffer is full, discarding.")
        conn.Close()
    }
}

// Remove a proxy connection from the pool and return it
// If not proxy connections are in the pool, request one
// and wait until it is available
// Returns an error if we couldn't get a proxy because it took too long
// or the tunnel is closing
func (c *Control) GetProxy() (proxyConn conn.Conn, err error) {
    var ok bool

    // get a proxy connection from the pool
    select {
    case proxyConn, ok = <-c.proxies:
        if !ok {
            err = fmt.Errorf("No proxy connections available, control is closing")
            return
        }
    default:
    // no proxy available in the pool, ask for one over the control channel
        c.conn.Debug("No proxy in pool, requesting proxy from control . . .")
        if err = util.PanicToError(func() {
            c.out <- &msg.ReqProxy{}
        }); err != nil {
            return
        }

            select {
            case proxyConn, ok = <-c.proxies:
                if !ok {
                    err = fmt.Errorf("No proxy connections available, control is closing")
                    return
                }

            case <-time.After(pingTimeoutInterval):
                err = fmt.Errorf("Timeout trying to get proxy connection")
                return
            }
    }
    return
}

// Called when this control is replaced by another control
// this can happen if the network drops out and the client reconnects
// before the old tunnel has lost its heartbeat
func (c *Control) Replaced(replacement *Control) {
    c.conn.Info("Replaced by control: %s", replacement.conn.Id())

    // set the control id to empty string so that when stopper()
    // calls registry.Del it won't delete the replacement
    c.id = ""

    // tell the old one to shutdown
    c.shutdown.Begin()
}

修改了 ngrok/src/ngrok/server/control.go

以防版本不同,列出修改的具体内容

在 func NewControl(){} 内添加了一个方法,然后

 func NewControl(ctlConn conn.Conn, authMsg *msg.Auth) {
     //省略
     //读取文件方法
     readLine := func(token string, filename string) (bool, error) {

        if token == "" {
            return false, nil;
        }
        f, err := os.Open(filename)
        if err != nil {
            return false, err
        }
        buf := bufio.NewReader(f)
        for {
            line, err := buf.ReadString('\n')
            line = strings.TrimSpace(line)
            if line == token {
                return true, nil
            }
            if err != nil {
                if err == io.EOF {
                    return false, nil
                }
                return false, err
            }
        }
        return false, nil
}
    //省略
    //调用验证
    authd, err := readLine(authMsg.User, "authtokens.txt")

    if authd != true {
        failAuth(fmt.Errorf("authtoken %s invalid", "is"));
        return
}
     //省略
 }

这个验证直接 比较是否相等如 "123456" 或 "abcd:123456" 并没区别,看自己设计吧

修改后重新编译服务端 , 在执行文件同目录建立一个 用户文件,"authtokens.txt"

//如果 客户端参数 
-authtoken "username:password"
//服务端authtokens.txt包含相同字符串,每一个token一行,循环遍历比较
username:password

至于编译我是参照
一分钟实现内网穿透(ngrok服务器搭建)

ngrok版本 1.7
ubuntu 18.04
VMware 12pro

启动ngrok 客户端 偶现连接到其他端口,如配置的是http:8088 https:8089 连接时,http和https都连接到了8089,更有可能连接到 未配置的80端口去,以至于无法访问,当然 如果只使用80 端口 应该不会出现大问题

0

老兄为什么我按照你这样配置,然后还是没有身份验证?

0
wang845252276
很倔也很天真 修改源码,有没有呢
11 个月之前 回复
Csdn user default icon
上传中...
上传图片
插入图片
抄袭、复制答案,以达到刷声望分或其他目的的行为,在CSDN问答是严格禁止的,一经发现立刻封号。是时候展现真正的技术了!
其他相关推荐
构建自己的Ngrok服务器
ngrok是什么(借别人的一段来说明)? 做前端开发的童鞋或许不会太陌生。 如果你完全不知道它是什么东西,可以在它的github项目上了解下:https://github.com/inconshreveable/ngrok 这里只提下它的核心功能:能够将你本机的HTTP服务(站点)或TCP服务,通过部署有ngrok服务的外网伺服器暴露给外网访问! 如上封面图所示,举
3分钟快速搭建ngrok服务器
一、前提准备: 云服务器centos+已解析域名xxxx.com 二、环境搭建: 1. 基础环境 yum -y install zlib-devel openssl-devel perl hg cpio expat-devel gettext-devel curl curl-devel perl-ExtUtils-MakeMaker hg wget gcc gcc-c++ git   ...
通过nginx代理搭建自己的ngrok服务器
内网穿透想必开发过微信的同志都很了解,大部分人选择网上寻找各种现成的,比如ngrok官网或者花生壳(花生壳免费的和充值6元也不再给开放80端口,做不了微信开发)之类的。但是世界上没有免费的午餐,要不就是收费,要不就是免费但是偶尔会出现连接失败的问题(当然大多数时间是没有问题的)。 但是公用的总是受制于人的,所以可以自己搭建一个ngrok的服务 我的ngrok是:ngrok.luckylxh.to...
10分钟教你搭建自己的ngrok服务器
内网穿透想必开发过微信的同志都很了解,大部分人选择网上寻找各种现成的,比如ngrok官网、ittun-ngrok、sunny-ngrok或者花生壳之类的。但是世界上没有免费的午餐,要不就是收费,要不就是免费但是偶尔会出现连接失败的问题(当然大多数时间是没有问题的)。 偶然,正在测试微信的某些功能,但是正在使用的ittun-ngrok连接失败了。导致测试无法进行,最终萌生出自己搭建一个ngrok服...
阿里云搭建自己的ngrok服务-实现内网穿透
参考博文:https://blog.csdn.net/qq_34292044/article/details/78559128https://blog.csdn.net/huanxiang201311/article/details/72725891一.环境准备        1.固定的ip地址,我用的是阿里云,系统cenos6,比较老的系统。阿里云有自己的安全组策略,请把你自己的端口加进安全组里...
ngrok使用自己的证书通过https访问
ngrok使用自己的证书通过https访问
搭建Ngrok服务器实现内网的计算机实现远程桌面
一、部署环境 1、linux外网系统服务器一台 2、一个域名,域名可以不备案,绑定到服务器上 二、搭建Ngrok服务器(开始进行服务器搭建) 1.安装GNU编译器套件、git(用于下载Ngrok源码)、以及GO语言环境 [root@centos ~]#  yum -y install gcc [root@centos ~]#  yum install git -y [root@ce...
一分钟实现内网穿透(ngrok服务器搭建)
简单来说内网穿透的目的是:让外网能访问你本地的应用,例如在外网打开你本地http://127.0.0.1指向的Web站点。 最近公司的花生壳到期了,要续费,发现价格一直在涨,都是5年以上的老用户,旗舰版都没有实现内网完全穿透,打算自己动手替换这个服务,中间走了不少的弯路,这里记录一些文字为大家提供参考。
CentOS搭建ngrok服务器及跨平台客户端内网穿透的使用
有些时候需要开发微信或者支付等接口时需要一个公网地址,调试的时候只能上传到服务器检查错误,这样不断的在服务器上调试,效率是非常低的。当然,我们可以使用花生壳一类的内网穿透软件,但是免费版限制重重,不如自己搭建一个内网穿透的服务器,用起来的心应手,也不用担心隐私泄露等问题。目前比较流行的就是ngrok,这个软件有官方的服务器,国内是无法直接使用的(需要翻出去),但是这个软件是开源的,那么自己搭建一个...
Windows搭建ngrok服务器、Linux搭建ngrok服务器、支持用户管理
Windows搭建ngrok服务器,Linux搭建ngrok服务器,支持用户管理,http子域名授权,tcp端口授权,支持各类32位、64位操作系统;利用云计算的强大力量,快速编译生成ngrok服务端和客户端,并自动生成配置脚本,实现绿色免安装,下载即可使用,傻瓜式操作。
自己的ngrok服务器
自己的ngrok服务器,实现内网穿透,外网访问内网,可本地开发微信不需要上传服务器时间: 2015-10-06 01:45 栏目: Linux 浏览: 125608 赞: 63 踩: 15 字体: 大 中 小以下为本篇文章全部内容:视频教程:http://video.tudou.com/v/XMTc4ODY3MTg4MA==.html        ngrok 是一个使用go语言编写的反向代理软件...
Centos 7 ngrok服务器搭建
 一.安装go和git git用来下载ngrok,go用来编译生成客户端和服务端 #安装git yum install -y git # 安装 Go 从官网下载:https://golang.org/dl/ wget https://storage.googleapis.com/golang/go1.8.linux-amd64.tar.gz #解压缩到/usr/local目录 ...
CentOS 7下ngrok服务器搭建
一、安装ngrok编译环境 1、安装git所需要的依赖包 yum -y install zlib-devel openssl-devel perl hg cpio expat-devel gettext-devel curl curl-devel perl-ExtUtils-MakeMaker hg wget gcc gcc-c++libxsltxmlto yum -y ins...
web服务器搭建之ngrok篇
ngrok介绍许多刚学java web的同学(包括我自己)肯定都非常好奇,如何在外网上访问自己做的项目,跟我们本地访问tomcat有什么区别?今天就向大家介绍一个非常强大的外网映射工具:ngrok.ngrok可以把你的本地ip(127.0.0.1|localhost)映射成一个公网域名,这样所有人都可以通过这个域名来访问你的项目,这个功能对本地调试,特别是微信公众号开发带来了极大的便利.示例: h
centos7 搭建ngrok服务器实现内网穿透
一、内网穿透概要 为了理解内网穿透我们先来了解几个概念: 1.1、IP地址 网络中唯一定位一台设备的逻辑地址,类似我们的电话号码,在互联网中我们访问一个网站或使用一个网络服务最终都需要通过IP定位到每一台主机,IP地址是IP协议提供的一种统一的地址格式,它为互联网上的每一个网络和每一台主机分配一个逻辑地址,以此来屏蔽物理地址的差异。 内网IP可以同时出现在多个不同的局域网络中,如A公司的U...
使用node和ngrok在本地搭建项目,让外网的人也可以浏览
安装一下node,express,然后如下然后就可以使用http://127.0.0.1:8080在本地访问,想让外网的也能访问这个页面,那么需要下载ngrok地址:https://dashboard.ngrok.com/get-started     可以使用GitHub登录下载到D盘解压之后(我这里使用GitHub登录的,下载之后就可以直接使用,但是我看有些人好像注册之后在登录的好像需要授权码...
编译好的Windows版Ngrok服务器端
编译好的Windows版Ngrok服务器端,有32和64位两个版本。解压就能用,网上很难找。
ngrok搭建web服务器(内网穿透)
ngrok可以做web服务器,可以做内网穿透,如公司内网外面的网络不能访问,这时候就需要到它了。 可以上官网(https://ngrok.com/)或者中文网(http://www.ngrok.cn/)下载ngrok 。 下载解压后得到这样一个文件,我把它放在了D盘根目录; win+r输入cmd打开控制台, 输入命令 : d: 先切换盘符目录,随后输入命令: ngrok http ...
Ubuntu上搭建自己的ngrok服务器
Ubuntu上搭建自己的ngrok服务器 参考网站:http://www.sunnyos.com/article-show-48.html 上面的内容似乎是sunny大神本人写的,了解的越多,发现自己懂得越少,但是对知识的渴求和好奇却越深。 我们暂时做的只是在局域网上搭建ngrok服务器,利用ngrok技术实现局域网上开发板的局域网nat,当我们访问服务器的局域网ip和端口时,实际远程访问控...
linux服务器搭建ngrok服务-实现内网穿透
1.ngrok依赖gcc 和 golang的安装已经存在请忽略 # 安装 gcc yum -y install gcc yum -y install gcc-c++ # 安装 golang , 下载地址在https://studygolang.com/dl中找的,想换版本可以在这里找 wget https://studygolang.com/dl/golang/go1.8.linux-...
使用Ngrok实现内网穿透|附国内免费服务器
快速搭建Ngrok-含免费服务器什么是内网穿透?Ngrok是什么?为什么需要内网穿透?使用ubantu16搭建ngrok服务器下载ngrok源码安装go语言配置环境变量生成证书编译启动测试福利 什么是内网穿透? 内网穿透,即NAT穿透,网络连接时术语,计算机是局域网内时,外网与内网的计算机节点需要连接通信,有时就会出现不支持内网穿透。简单来说,就是让身处局域网的电脑,被大家都能访问的技术。 Ngr...
轻松搭建内网穿透服务Ngrok
内网穿透服务Ngrok对于很多玩服务器的朋友来说应该不陌生吧,今天在疼云阁(腾云阁 - 腾讯云)学习了一篇文章如何利用腾讯云轻松搭建内网穿透服务Ngrok,在这里跟大家分享一下这篇文章,本人觉得教程写得比较明朗,所以分享给大家看一下。 在最近的开发过程中,遇到了一个尴尬的问题,外网环境下无法访问内网(本地虚拟机)的Ubuntu系统中的WEB服务,很难将自己做好的网站和页面展示给别人看,并接受
内网穿透-搭建ngrok服务器
有时需要让外网访问本机的web或者远程或者微信开发调试等其他,但本机没有公网ip就需要内网穿透,用花生壳等又受限制那就可以尝试自己搭建。 需要有个带公网IP的服务器和域名,我们可以用 ngrok 代码编译到自己服务器上(就相当于花生壳服务器),ngrok官方目前只开源1.x版本,下面以我的Centos6,目标域名http://www.wintercoder.com:81/(已废弃)为例。 先推...
搭建自己的ngrok服务(内网穿透 使用简单)
在国内开发微信公众号、企业号以及做前端开发的朋友想必对ngrok都不陌生吧,就目前来看,ngrok可是最佳的在内网调试微信服务的tunnel工 具。记得今年春节前,ngrok.com提供的服务还一切正常呢,但春节后似乎就一切不正常了。ngrok.com无法访问,ngrok虽然能连上 ngrok.com提供的服务,但微信端因为无法访问ngrok.com,导致消息一直无法发送到我们的服务地址上,比如xx
ubuntu 16.04搭建ngrok内网穿透服务
从公网访问内网部署的服务有很多方式,比如以花生壳为代表的商业内网穿透服务,要么收费,免费的速度慢操作麻烦。本文尝试用开源的ngrok服务,自己在ubuntu16.04搭建代理转接服务器,将外网的请求转接到内网,实现从公网无障碍高速访问内网服务。大概步骤也比较简单(4步):1、在公网主机上(我用的阿里云)部署ngrok源码;2、生成证书;3、编译生成主机服务(最终生成二进制文件ngro...
Linux做服务器搭建ngrok服务器
(假设服务器地址为:123.123.123.123)1.  前置条件1)  安装go语言# apt-get install golang2)   安装git#apt-get install git 或# yuminstall git2.   将ngrok源代码克隆回本地1)   创建ngrok的目录# mkdir ngrok2)   源码克隆# git clone https://github.c...
从零教你搭建ngrok服务,解决外网调试本地站点
转自:https://morongs.github.io/2016/12/28/dajian-ngrok/ 什么是ngrok呢?ngrok是一个反向代理,它能够让你本地的web服务或tcp服务通过公共的端口和外部建立一个安全的通道,使得外网可以访问本地的计算机服务。 也就是说,我们提供的服务(比如web站点)无需搭建在外部服务器,只要通过ngrok把站点映射出去,别人即可直接访问到我们的服务。 ...
阿里云centos搭建ngrok服务
      上篇文章《移动程序本地调试过程中常用的内网穿透服务》介绍了常用的几种ngrok服务,本篇文章主要将自建ngrok服务的过程记录下来,方便后续使用。 1.准备工作 阿里云centos7.5一台(独立IP地址) 已备案的域名一个(ICP未备案的域名微信无法授权验证) 二级域名解析到云服务器ip 将ngrok.kfpt.cn和*.ngrok.kfpt.cn二级域名解析到服务器ip ...
ngrok服务搭建
1,安装gcc(编译器套件) [root@192 /]# yum install gcc 2,安装git(分布式版本控制系统) [root@192 /]# yum install git 3,安装go语言环境(因为ngrok的运行环境需要) 在这个站点查看下载最新版 https://www.golangtc.com/static/go/ (linux-amd64是64位的。linux-386是32...
内网穿透,本地网站手机访问,本地网站别人访问,10分钟教你搭建自己的ngrok服务器
https://blog.csdn.net/duyusean/article/details/80011540 文章地址,自己去上面学习  https://blog.csdn.net/duyusean/article/details/80011540
利用ngrok 做本地临时服务器 达到公网效果
如题 当我们在内网开发的时候 和别人联调功能很方便 可是如果不是内网的情况 难道还要把代码push到服务器 进行联调或者给客户展示产品吗 肯定不需要那样啦  免费的ngrok即可达到效果 第一步:登录https://ngrok.com/ 第二部:注册 也可以用github账号快速登录 第三部:下载 很简单 下载之后解压 在当前目录打开终端(命令行工具) $ ./ngro...
腾讯云等云服务器搭建Ngrok内网穿透服务器
  第一部分:准备工作  域名解析(一般域名解析需要10分钟生效,所以我们第一步来做域名解析)        由于我的备案主体在腾讯云,所以我就以我的域名为例子         一定要添加一条主机记录为* 的这样我们才能通过 *.域名.com *为任意值 访问到应用。  记录值为服务器的公网IP      2.服务器的基本环境       Centos6.8 64位  1H、...
ngrok自己电脑做服务器一键生成
ngrok可一键生成服务器方便外网访问调试
ubuntu上搭建ngrok服务器
说在前面 :           ngrok是一个比较好用的内网穿透工具,通过他外网用户可以直接访问内网的设备,本文主要讲述如何自己搭建ngrok服务器。 准备:        为了搭建服务器,需要有一个外网ip地址,现在云服务很方便,可以随便租用一台设备来搭建服务器。 安装go编译器:       网上有很多安装的教程,需要注意的是1.4之后的版本需要使用1.4版本来进
分享一下在centos上搭建ngrok服务器的过程吧!
最近开发自己的微信公众号时,发现在本地写代码,然后要传到服务器上面去,非常的不方便,通过百度,知道了一款开源软件ngrok,在它的服务器在国外,灰常的慢,访问的速度简直不能直视,于是百度解决办法,没想到ngrok服务器可以自己搭建,跟着教程一步步搭建ngrok,在这里做一下笔记。 准备工作: 1、一台公网可以访问到得linux服务器(centos) 2、把需要做的域名解析到服务器
阿里云通过nginx,docker完美搭建Ngrok服务器(http,https)
阿里云服务通过docker,ngnix完美搭建Ngrok服务器
内网穿透、反向代理(ngrok服务器搭建)
内网穿透的目的是:让外网能访问你本地的应用,例如在外网打开你本地http://127.0.0.1指向的Web站点。一、ngrokngrok是一个反向代理,通过在公共的端点和本地运行的Web服务器之间建立一个安全的通道。ngrok可捕获和分析所有通道上的流量,便于后期分析与响应。开源免费官网:https://ngrok.com/源码:https://github.com/inconshreveabl
ngrok的使用和在(window)本地部署微信服务器
主要是借鉴了这两位大哥的代码和解释 1,在局域网中部署微信服务器 2,微信公众平台申请测试接口URL和TOKEN的配置,怎么在本地让微信能通过80端口访问 机制:先启动你的本地服务,比如说的启动的是django的服务,具体为127.0.0.1:8000。然后通过ngrok将你启动的这个端口的地址换成一个临时的域名(具体细节不清楚。)然后通过新生成的这个域名去配置微信公众账号里的url
Ngrok内网穿透服务器解决方案
原文地址:https://www.cnblogs.com/irich/p/8674796.html 不用花生壳、nat123等内网穿透软件的原因: 1、免费的限制多 2、收费的价格高 自己搞个网站、博客什么的成本高了自然不合适,当然土豪另当别论了。 此次方案:279元/3年(购买云主机) 自己手动实现无限制内网穿透 一、前提条件   1、需要一台服务器 这里推荐阿里云,1核2G 现在价...
ngrok 服务器 客户端的安装,使用(包含二级域名的配置)
服务端的安装 条件: 需要一台公网服务器 1.在服务器上安装go的环境变量 2.安装git yum –y install git 3.配置二级域名 在服务器中dns解析中配置二级域名的解析,需要在域名管理里面设置二级域名的解析 4.配置nginx 4.1 需要在nginx中配置二级域名的访问,在nginx.conf中配置一个server: serv...
文章热词 机器学习教程 Objective-C培训 交互设计视频教程 颜色模型 设计制作学习
相关热词 mysql关联查询两次本表 native底部 react extjs glyph 图标 搭建云计算服务器 服务器web搭建教程