// NewAPIServer creates a new APIServer object with default parameters func NewAPIServer() *APIServer { s := APIServer{ WideOpenPort: 8080, Address: util.IP(net.ParseIP("127.0.0.1")), PublicAddressOverride: util.IP(net.ParseIP("")), ReadOnlyPort: 7080, APIRate: 10.0, APIBurst: 200, SecurePort: 6443, APIPrefix: "/api", EventTTL: 1 * time.Hour, AuthorizationMode: "AlwaysAllow", AdmissionControl: "AlwaysAdmit", EnableLogsSupport: true, MasterServiceNamespace: api.NamespaceDefault, ClusterName: "kubernetes", SyncPodStatus: true, RuntimeConfig: make(util.ConfigurationMap), KubeletConfig: client.KubeletConfig{ Port: 10250, EnableHttps: false, }, } return &s }
// NewAPIServer creates a new APIServer object with default parameters func NewAPIServer() *APIServer { s := APIServer{ InsecurePort: 8080, InsecureBindAddress: util.IP(net.ParseIP("127.0.0.1")), BindAddress: util.IP(net.ParseIP("0.0.0.0")), SecurePort: 6443, APIRate: 10.0, APIBurst: 200, APIPrefix: "/api", EventTTL: 1 * time.Hour, AuthorizationMode: "AlwaysAllow", AdmissionControl: "AlwaysAdmit", EtcdPathPrefix: master.DefaultEtcdPathPrefix, EnableLogsSupport: true, MasterServiceNamespace: api.NamespaceDefault, ClusterName: "kubernetes", CertDirectory: "/var/run/kubernetes", RuntimeConfig: make(util.ConfigurationMap), KubeletConfig: client.KubeletConfig{ Port: ports.KubeletPort, EnableHttps: true, HTTPTimeout: time.Duration(5) * time.Second, }, } return &s }
// NewKubeletServer will create a new KubeletServer with default values. func NewKubeletServer() *KubeletServer { return &KubeletServer{ SyncFrequency: 10 * time.Second, FileCheckFrequency: 20 * time.Second, HTTPCheckFrequency: 20 * time.Second, EnableServer: true, Address: util.IP(net.ParseIP("0.0.0.0")), Port: ports.KubeletPort, ReadOnlyPort: ports.KubeletReadOnlyPort, PodInfraContainerImage: dockertools.PodInfraContainerImage, RootDirectory: defaultRootDir, RegistryBurst: 10, EnableDebuggingHandlers: true, MinimumGCAge: 1 * time.Minute, MaxPerPodContainerCount: 5, MaxContainerCount: 100, AuthPath: "/var/lib/kubelet/kubernetes_auth", CadvisorPort: 4194, HealthzPort: 10248, HealthzBindAddress: util.IP(net.ParseIP("127.0.0.1")), OOMScoreAdj: -900, MasterServiceNamespace: api.NamespaceDefault, ImageGCHighThresholdPercent: 90, ImageGCLowThresholdPercent: 80, NetworkPluginName: "", HostNetworkSources: kubelet.FileSource, CertDirectory: "/var/run/kubernetes", NodeStatusUpdateFrequency: 10 * time.Second, ResourceContainer: "/kubelet", } }
// NewProxyServer creates a new ProxyServer object with default parameters func NewProxyServer() *ProxyServer { return &ProxyServer{ BindAddress: util.IP(net.ParseIP("0.0.0.0")), HealthzPort: 10249, HealthzBindAddress: util.IP(net.ParseIP("127.0.0.1")), OOMScoreAdj: -899, ResourceContainer: "/kube-proxy", } }
// NewSchedulerServer creates a new SchedulerServer with default parameters func NewSchedulerServer() *SchedulerServer { s := SchedulerServer{ Port: ports.SchedulerPort, Address: util.IP(net.ParseIP("127.0.0.1")), FailoverTimeout: time.Duration((1 << 62) - 1).Seconds(), ExecutorRunProxy: true, ExecutorSuicideTimeout: execcfg.DefaultSuicideTimeout, MesosAuthProvider: sasl.ProviderName, MesosMaster: defaultMesosMaster, MesosUser: defaultMesosUser, ReconcileInterval: defaultReconcileInterval, ReconcileCooldown: defaultReconcileCooldown, Checkpoint: true, FrameworkName: defaultFrameworkName, HA: false, mux: http.NewServeMux(), KubeletCadvisorPort: 4194, // copied from github.com/GoogleCloudPlatform/kubernetes/blob/release-0.14/cmd/kubelet/app/server.go KubeletSyncFrequency: 10 * time.Second, } // cache this for later use. also useful in case the original binary gets deleted, e.g. // during upgrades, development deployments, etc. if filename, err := osext.Executable(); err != nil { log.Fatalf("failed to determine path to currently running executable: %v", err) } else { s.executable = filename s.KMPath = filename } return &s }
// NewProxyServer creates a new ProxyServer object with default parameters func NewProxyServer() *ProxyServer { return &ProxyServer{ BindAddress: util.IP(net.ParseIP("0.0.0.0")), HealthzPort: 10249, OOMScoreAdj: -899, } }
// SimpleRunKubelet is a simple way to start a Kubelet talking to dockerEndpoint, using an etcdClient. // Under the hood it calls RunKubelet (below) func SimpleRunKubelet(client *client.Client, etcdClient tools.EtcdClient, dockerClient dockertools.DockerInterface, hostname, rootDir, manifestURL, address string, port uint, masterServiceNamespace string, volumePlugins []volume.Plugin) { kcfg := KubeletConfig{ KubeClient: client, EtcdClient: etcdClient, DockerClient: dockerClient, HostnameOverride: hostname, RootDirectory: rootDir, ManifestURL: manifestURL, NetworkContainerImage: kubelet.NetworkContainerImage, Port: port, Address: util.IP(net.ParseIP(address)), EnableServer: true, EnableDebuggingHandlers: true, SyncFrequency: 3 * time.Second, MinimumGCAge: 10 * time.Second, MaxContainerCount: 5, MasterServiceNamespace: masterServiceNamespace, VolumePlugins: volumePlugins, } RunKubelet(&kcfg) }
// SimpleRunKubelet is a simple way to start a Kubelet talking to dockerEndpoint, using an API Client. // Under the hood it calls RunKubelet (below) func SimpleKubelet(client *client.Client, dockerClient dockertools.DockerInterface, hostname, rootDir, manifestURL, address string, port uint, masterServiceNamespace string, volumePlugins []volume.VolumePlugin, tlsOptions *kubelet.TLSOptions, cadvisorInterface cadvisor.Interface, configFilePath string, cloud cloudprovider.Interface, osInterface kubecontainer.OSInterface) *KubeletConfig { imageGCPolicy := kubelet.ImageGCPolicy{ HighThresholdPercent: 90, LowThresholdPercent: 80, } diskSpacePolicy := kubelet.DiskSpacePolicy{ DockerFreeDiskMB: 256, RootFreeDiskMB: 256, } kcfg := KubeletConfig{ KubeClient: client, DockerClient: dockerClient, HostnameOverride: hostname, RootDirectory: rootDir, ManifestURL: manifestURL, PodInfraContainerImage: dockertools.PodInfraContainerImage, Port: port, Address: util.IP(net.ParseIP(address)), EnableServer: true, EnableDebuggingHandlers: true, HTTPCheckFrequency: 1 * time.Second, FileCheckFrequency: 1 * time.Second, SyncFrequency: 3 * time.Second, MinimumGCAge: 10 * time.Second, MaxPerPodContainerCount: 2, MaxContainerCount: 100, RegisterNode: true, MasterServiceNamespace: masterServiceNamespace, VolumePlugins: volumePlugins, TLSOptions: tlsOptions, CadvisorInterface: cadvisorInterface, ConfigFile: configFilePath, ImageGCPolicy: imageGCPolicy, DiskSpacePolicy: diskSpacePolicy, Cloud: cloud, NodeStatusUpdateFrequency: 10 * time.Second, ResourceContainer: "/kubelet", OSInterface: osInterface, CgroupRoot: "", ContainerRuntime: "docker", Mounter: mount.New(), DockerDaemonContainer: "/docker-daemon", SystemContainer: "", MaxPods: 32, DockerExecHandler: &dockertools.NativeExecHandler{}, } return &kcfg }
// NewSchedulerServer creates a new SchedulerServer with default parameters func NewSchedulerServer() *SchedulerServer { s := SchedulerServer{ Port: ports.SchedulerPort, Address: util.IP(net.ParseIP("127.0.0.1")), AlgorithmProvider: factory.DefaultProvider, } return &s }
// NewKubeletServer will create a new KubeletServer with default values. func NewKubeletServer() *KubeletServer { return &KubeletServer{ SyncFrequency: 10 * time.Second, FileCheckFrequency: 20 * time.Second, HTTPCheckFrequency: 20 * time.Second, EnableServer: true, Address: util.IP(net.ParseIP("0.0.0.0")), Port: ports.KubeletPort, ReadOnlyPort: ports.KubeletReadOnlyPort, PodInfraContainerImage: dockertools.PodInfraContainerImage, RootDirectory: defaultRootDir, RegistryBurst: 10, EnableDebuggingHandlers: true, MinimumGCAge: 1 * time.Minute, MaxPerPodContainerCount: 2, MaxContainerCount: 100, AuthPath: util.NewStringFlag("/var/lib/kubelet/kubernetes_auth"), // deprecated KubeConfig: util.NewStringFlag("/var/lib/kubelet/kubeconfig"), CadvisorPort: 4194, HealthzPort: 10248, HealthzBindAddress: util.IP(net.ParseIP("127.0.0.1")), RegisterNode: true, // will be ignored if no apiserver is configured OOMScoreAdj: -900, MasterServiceNamespace: api.NamespaceDefault, ImageGCHighThresholdPercent: 90, ImageGCLowThresholdPercent: 80, LowDiskSpaceThresholdMB: 256, NetworkPluginName: "", NetworkPluginDir: "/usr/libexec/kubernetes/kubelet-plugins/net/exec/", HostNetworkSources: kubelet.FileSource, CertDirectory: "/var/run/kubernetes", NodeStatusUpdateFrequency: 10 * time.Second, ResourceContainer: "/kubelet", CgroupRoot: "", ContainerRuntime: "docker", DockerDaemonContainer: "/docker-daemon", SystemContainer: "", ConfigureCBR0: false, DockerExecHandlerName: "native", } }
// NewCMServer creates a new CMServer with a default config. func NewCMServer() *CMServer { s := CMServer{ Port: ports.ControllerManagerPort, Address: util.IP(net.ParseIP("127.0.0.1")), ConcurrentEndpointSyncs: 5, ConcurrentRCSyncs: 5, NodeSyncPeriod: 10 * time.Second, ResourceQuotaSyncPeriod: 10 * time.Second, NamespaceSyncPeriod: 5 * time.Minute, PVClaimBinderSyncPeriod: 10 * time.Second, RegisterRetryCount: 10, PodEvictionTimeout: 5 * time.Minute, ClusterName: "kubernetes", } return &s }
func NewKubeletExecutorServer() *KubeletExecutorServer { k := &KubeletExecutorServer{ KubeletServer: app.NewKubeletServer(), SuicideTimeout: config.DefaultSuicideTimeout, cgroupPrefix: config.DefaultCgroupPrefix, } if pwd, err := os.Getwd(); err != nil { log.Warningf("failed to determine current directory: %v", err) } else { k.RootDirectory = pwd // mesos sandbox dir } k.Address = util.IP(net.ParseIP(defaultBindingAddress())) k.ShutdownFD = -1 // indicates unspecified FD return k }
// NewCMServer creates a new CMServer with a default config. func NewCMServer() *CMServer { s := CMServer{ Port: ports.ControllerManagerPort, Address: util.IP(net.ParseIP("127.0.0.1")), ConcurrentEndpointSyncs: 5, NodeSyncPeriod: 10 * time.Second, ResourceQuotaSyncPeriod: 10 * time.Second, NamespaceSyncPeriod: 5 * time.Minute, RegisterRetryCount: 10, PodEvictionTimeout: 5 * time.Minute, NodeMilliCPU: 1000, NodeMemory: resource.MustParse("3Gi"), SyncNodeList: true, ClusterName: "kubernetes", } return &s }
// NewCMServer creates a new CMServer with a default config. func NewCMServer() *CMServer { s := CMServer{ Port: ports.ControllerManagerPort, Address: util.IP(net.ParseIP("127.0.0.1")), NodeSyncPeriod: 10 * time.Second, ResourceQuotaSyncPeriod: 10 * time.Second, RegisterRetryCount: 10, PodEvictionTimeout: 5 * time.Minute, NodeMilliCPU: 1000, NodeMemory: resource.MustParse("3Gi"), SyncNodeList: true, SyncNodeStatus: false, KubeletConfig: client.KubeletConfig{ Port: ports.KubeletPort, EnableHttps: false, }, } return &s }
// RunKubelet starts the Kubelet. func (c *NodeConfig) RunKubelet() { // TODO: clean this up and make it more formal (service named 'dns'?). Use multiple ports. clusterDNS := c.KubeletConfig.ClusterDNS if clusterDNS == nil { if service, err := c.Client.Endpoints(kapi.NamespaceDefault).Get("kubernetes"); err == nil { if ip, ok := firstIP(service, 53); ok { if err := cmdutil.WaitForSuccessfulDial(false, "tcp", fmt.Sprintf("%s:%d", ip, 53), 50*time.Millisecond, 0, 2); err == nil { c.KubeletConfig.ClusterDNS = util.IP(net.ParseIP(ip)) } } } } c.KubeletConfig.DockerClient = c.DockerClient // updated by NodeConfig.EnsureVolumeDir c.KubeletConfig.RootDirectory = c.VolumeDir go func() { glog.Fatal(c.KubeletServer.Run(c.KubeletConfig)) }() }
// SimpleRunKubelet is a simple way to start a Kubelet talking to dockerEndpoint, using an API Client. // Under the hood it calls RunKubelet (below) func SimpleRunKubelet(client *client.Client, dockerClient dockertools.DockerInterface, hostname, rootDir, manifestURL, address string, port uint, masterServiceNamespace string, volumePlugins []volume.Plugin, tlsOptions *kubelet.TLSOptions, cadvisorInterface cadvisor.Interface, configFilePath string) { imageGCPolicy := kubelet.ImageGCPolicy{ HighThresholdPercent: 90, LowThresholdPercent: 80, } kcfg := KubeletConfig{ KubeClient: client, DockerClient: dockerClient, HostnameOverride: hostname, RootDirectory: rootDir, ManifestURL: manifestURL, PodInfraContainerImage: kubelet.PodInfraContainerImage, Port: port, Address: util.IP(net.ParseIP(address)), EnableServer: true, EnableDebuggingHandlers: true, StatusUpdateFrequency: 3 * time.Second, SyncFrequency: 3 * time.Second, MinimumGCAge: 10 * time.Second, MaxPerPodContainerCount: 5, MaxContainerCount: 100, MasterServiceNamespace: masterServiceNamespace, VolumePlugins: volumePlugins, TLSOptions: tlsOptions, CadvisorInterface: cadvisorInterface, ConfigFile: configFilePath, ImageGCPolicy: imageGCPolicy, } RunKubelet(&kcfg) }
// NewKubeletServer will create a new KubeletServer with default values. func NewKubeletServer() *KubeletServer { return &KubeletServer{ SyncFrequency: 10 * time.Second, FileCheckFrequency: 20 * time.Second, HTTPCheckFrequency: 20 * time.Second, StatusUpdateFrequency: 20 * time.Second, EnableServer: true, Address: util.IP(net.ParseIP("127.0.0.1")), Port: ports.KubeletPort, PodInfraContainerImage: kubelet.PodInfraContainerImage, RootDirectory: defaultRootDir, RegistryBurst: 10, EnableDebuggingHandlers: true, MinimumGCAge: 1 * time.Minute, MaxPerPodContainerCount: 5, MaxContainerCount: 100, CadvisorPort: 4194, OOMScoreAdj: -900, MasterServiceNamespace: api.NamespaceDefault, ImageGCHighThresholdPercent: 90, ImageGCLowThresholdPercent: 80, } }
"github.com/GoogleCloudPlatform/kubernetes/pkg/util" "github.com/GoogleCloudPlatform/kubernetes/pkg/version/verflag" "github.com/coreos/go-etcd/etcd" "github.com/golang/glog" ) var ( // Note: the weird ""+ in below lines seems to be the only way to get gofmt to // arrange these text blocks sensibly. Grrr. port = flag.Int("port", 8080, ""+ "The port to listen on. Default 8080. It is assumed that firewall rules are "+ "set up such that this port is not reachable from outside of the cluster. It is "+ "further assumed that port 443 on the cluster's public address is proxied to this "+ "port. This is performed by nginx in the default setup.") address = util.IP(net.ParseIP("127.0.0.1")) publicAddressOverride = flag.String("public_address_override", "", ""+ "Public serving address. Read only port will be opened on this address, "+ "and it is assumed that port 443 at this address will be proxied/redirected "+ "to '-address':'-port'. If blank, the address in the first listed interface "+ "will be used.") readOnlyPort = flag.Int("read_only_port", 7080, ""+ "The port from which to serve read-only resources. If 0, don't serve on a "+ "read-only address. It is assumed that firewall rules are set up such that "+ "this port is not reachable from outside of the cluster.") securePort = flag.Int("secure_port", 8443, "The port from which to serve HTTPS with authentication and authorization. If 0, don't serve HTTPS ") tlsCertFile = flag.String("tls_cert_file", "", ""+ "File containing x509 Certificate for HTTPS. (CA cert, if any, concatenated after server cert). "+ "If HTTPS serving is enabled, and --tls_cert_file and --tls_private_key_file are not provided, "+ "a self-signed certificate and key are generated for the public address and saved to /var/run/kubernetes.") tlsPrivateKeyFile = flag.String("tls_private_key_file", "", "File containing x509 private key matching --tls_cert_file.")
"github.com/GoogleCloudPlatform/kubernetes/pkg/standalone" "github.com/GoogleCloudPlatform/kubernetes/pkg/util" "github.com/GoogleCloudPlatform/kubernetes/pkg/version/verflag" "github.com/golang/glog" ) const defaultRootDir = "/var/lib/kubelet" var ( config = flag.String("config", "", "Path to the config file or directory of files") syncFrequency = flag.Duration("sync_frequency", 10*time.Second, "Max period between synchronizing running containers and config") fileCheckFrequency = flag.Duration("file_check_frequency", 20*time.Second, "Duration between checking config files for new data") httpCheckFrequency = flag.Duration("http_check_frequency", 20*time.Second, "Duration between checking http for new data") manifestURL = flag.String("manifest_url", "", "URL for accessing the container manifest") enableServer = flag.Bool("enable_server", true, "Enable the info server") address = util.IP(net.ParseIP("127.0.0.1")) port = flag.Uint("port", ports.KubeletPort, "The port for the info server to serve on") hostnameOverride = flag.String("hostname_override", "", "If non-empty, will use this string as identification instead of the actual hostname.") networkContainerImage = flag.String("network_container_image", kubelet.NetworkContainerImage, "The image that network containers in each pod will use.") dockerEndpoint = flag.String("docker_endpoint", "", "If non-empty, use this for the docker endpoint to communicate with") etcdServerList util.StringList etcdConfigFile = flag.String("etcd_config", "", "The config file for the etcd client. Mutually exclusive with -etcd_servers") rootDirectory = flag.String("root_dir", defaultRootDir, "Directory path for managing kubelet files (volume mounts,etc).") allowPrivileged = flag.Bool("allow_privileged", false, "If true, allow containers to request privileged mode. [default=false]") registryPullQPS = flag.Float64("registry_qps", 0.0, "If > 0, limit registry pull QPS to this value. If 0, unlimited. [default=0.0]") registryBurst = flag.Int("registry_burst", 10, "Maximum size of a bursty pulls, temporarily allows pulls to burst to this number, while still not exceeding registry_qps. Only used if --registry_qps > 0") runonce = flag.Bool("runonce", false, "If true, exit after spawning pods from local manifests or remote urls. Exclusive with --etcd_servers and --enable-server") enableDebuggingHandlers = flag.Bool("enable_debugging_handlers", true, "Enables server endpoints for log collection and local running of containers and commands") minimumGCAge = flag.Duration("minimum_container_ttl_duration", 1*time.Minute, "Minimum age for a finished container before it is garbage collected. Examples: '300ms', '10s' or '2h45m'") maxContainerCount = flag.Int("maximum_dead_containers_per_container", 5, "Maximum number of old instances of a container to retain per container. Each container takes up some disk space. Default: 5.") authPath = flag.String("auth_path", "", "Path to .kubernetes_auth file, specifying how to authenticate to API server.")
func BuildKubernetesNodeConfig(options configapi.NodeConfig) (*NodeConfig, error) { kubeClient, _, err := configapi.GetKubeClient(options.MasterKubeConfig) if err != nil { return nil, err } if options.NodeName == "localhost" { glog.Warningf(`Using "localhost" as node name will not resolve from all locations`) } var dnsIP net.IP if len(options.DNSIP) > 0 { dnsIP = net.ParseIP(options.DNSIP) if dnsIP == nil { return nil, fmt.Errorf("Invalid DNS IP: %s", options.DNSIP) } } clientCAs, err := util.CertPoolFromFile(options.ServingInfo.ClientCA) if err != nil { return nil, err } imageTemplate := variable.NewDefaultImageTemplate() imageTemplate.Format = options.ImageConfig.Format imageTemplate.Latest = options.ImageConfig.Latest var path string var fileCheckInterval int64 if options.PodManifestConfig != nil { path = options.PodManifestConfig.Path fileCheckInterval = options.PodManifestConfig.FileCheckIntervalSeconds } var dockerExecHandler dockertools.ExecHandler switch options.DockerConfig.ExecHandlerName { case configapi.DockerExecHandlerNative: dockerExecHandler = &dockertools.NativeExecHandler{} case configapi.DockerExecHandlerNsenter: dockerExecHandler = &dockertools.NsenterExecHandler{} } kubeAddress, kubePortStr, err := net.SplitHostPort(options.ServingInfo.BindAddress) if err != nil { return nil, fmt.Errorf("cannot parse node address: %v", err) } kubePort, err := strconv.Atoi(kubePortStr) if err != nil { return nil, fmt.Errorf("cannot parse node port: %v", err) } address := util.IP{} if err := address.Set(kubeAddress); err != nil { return nil, err } // declare the OpenShift defaults from config server := kapp.NewKubeletServer() server.Config = path server.RootDirectory = options.VolumeDirectory server.HostnameOverride = options.NodeName server.AllowPrivileged = true server.RegisterNode = true server.Address = address server.Port = uint(kubePort) server.ReadOnlyPort = 0 // no read only access server.ClusterDNS = util.IP(dnsIP) server.ClusterDomain = options.DNSDomain server.NetworkPluginName = options.NetworkPluginName server.HostNetworkSources = strings.Join([]string{kubelet.ApiserverSource, kubelet.FileSource}, ",") server.HTTPCheckFrequency = 0 // no remote HTTP pod creation access server.FileCheckFrequency = time.Duration(fileCheckInterval) * time.Second server.PodInfraContainerImage = imageTemplate.ExpandOrDie("pod") // prevents kube from generating certs server.TLSCertFile = options.ServingInfo.ServerCert.CertFile server.TLSPrivateKeyFile = options.ServingInfo.ServerCert.KeyFile if value := cmdutil.Env("OPENSHIFT_CONTAINERIZED", ""); len(value) > 0 { server.Containerized = value == "true" } // resolve extended arguments // TODO: this should be done in config validation (along with the above) so we can provide // proper errors if err := cmdflags.Resolve(options.KubeletArguments, server.AddFlags); len(err) > 0 { return nil, errors.NewAggregate(err) } cfg, err := server.KubeletConfig() if err != nil { return nil, err } // provide any config overrides cfg.StreamingConnectionIdleTimeout = 5 * time.Minute // TODO: should be set cfg.KubeClient = kubeClient cfg.DockerExecHandler = dockerExecHandler // TODO: could be cleaner if configapi.UseTLS(options.ServingInfo) { cfg.TLSOptions = &kubelet.TLSOptions{ Config: &tls.Config{ // Change default from SSLv3 to TLSv1.0 (because of POODLE vulnerability) MinVersion: tls.VersionTLS10, // RequireAndVerifyClientCert lets us limit requests to ones with a valid client certificate ClientAuth: tls.RequireAndVerifyClientCert, ClientCAs: clientCAs, }, CertFile: options.ServingInfo.ServerCert.CertFile, KeyFile: options.ServingInfo.ServerCert.KeyFile, } } else { cfg.TLSOptions = nil } config := &NodeConfig{ BindAddress: options.ServingInfo.BindAddress, AllowDisabledDocker: options.AllowDisabledDocker, Client: kubeClient, VolumeDir: options.VolumeDirectory, KubeletServer: server, KubeletConfig: cfg, } return config, nil }
"github.com/GoogleCloudPlatform/kubernetes/pkg/api" "github.com/GoogleCloudPlatform/kubernetes/pkg/client" "github.com/GoogleCloudPlatform/kubernetes/pkg/proxy" "github.com/GoogleCloudPlatform/kubernetes/pkg/proxy/config" "github.com/GoogleCloudPlatform/kubernetes/pkg/util" "github.com/GoogleCloudPlatform/kubernetes/pkg/util/exec" "github.com/GoogleCloudPlatform/kubernetes/pkg/util/iptables" "github.com/GoogleCloudPlatform/kubernetes/pkg/version/verflag" "github.com/coreos/go-etcd/etcd" "github.com/golang/glog" ) var ( etcdServerList util.StringList etcdConfigFile = flag.String("etcd_config", "", "The config file for the etcd client. Mutually exclusive with -etcd_servers") bindAddress = util.IP(net.ParseIP("0.0.0.0")) clientConfig = &client.Config{} ) func init() { client.BindClientConfigFlags(flag.CommandLine, clientConfig) flag.Var(&etcdServerList, "etcd_servers", "List of etcd servers to watch (http://ip:port), comma separated (optional). Mutually exclusive with -etcd_config") flag.Var(&bindAddress, "bind_address", "The IP address for the proxy server to serve on (set to 0.0.0.0 for all interfaces)") } func main() { flag.Parse() util.InitLogs() defer util.FlushLogs() verflag.PrintAndExitIfRequested()