code: func (i *TeleInstance) StartNode(tconf *service.Config) (*service.TeleportProcess, error) {
  	dataDir, err := ioutil.TempDir("", "cluster-"+i.Secrets.SiteName)
  	if err != nil {
  		return nil, trace.Wrap(err)
  	}
  	tconf.DataDir = dataDir
  
  	authServer := utils.MustParseAddr(net.JoinHostPort(i.Hostname, i.GetPortAuth()))
  	tconf.AuthServers = append(tconf.AuthServers, *authServer)
  	tconf.Token = "token"
  	tconf.UploadEventsC = i.UploadEventsC
  	var ttl time.Duration
  	tconf.CachePolicy = service.CachePolicy{
  		Enabled:   true,
  		RecentTTL: &ttl,
  	}
  	tconf.SSH.PublicAddrs = []utils.NetAddr{
  		utils.NetAddr{
  			AddrNetwork: "tcp",
  			Addr:        Loopback,
  		},
  		utils.NetAddr{
  			AddrNetwork: "tcp",
  			Addr:        Host,
  		},
  	}
  	tconf.Auth.Enabled = false
  	tconf.Proxy.Enabled = false
  
  	// Create a new Teleport process and add it to the list of nodes that
  	// compose this "cluster".
  	process, err := service.NewTeleport(tconf)
  	if err != nil {
  		return nil, trace.Wrap(err)
  	}
  	i.Nodes = append(i.Nodes, process)
  
  	// Build a list of expected events to wait for before unblocking based off
  	// the configuration passed in.
  	expectedEvents := []string{
  		service.NodeSSHReady,
  	}
  
  	// Start the process and block until the expected events have arrived.
  	receivedEvents, err := startAndWait(process, expectedEvents)
  	if err != nil {
  		return nil, trace.Wrap(err)
  	}
  
  	log.Debugf("Teleport node (in instance %v) started: %v/%v events received.",
  		i.Secrets.SiteName, len(expectedEvents), len(receivedEvents))
  	return process, nil
  }
docs: // StartNode starts a SSH node and connects it to the cluster.