// Copyright © 2021 sealos.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
package cmd
import (
"fmt"
"strings"
"github.com/spf13/cobra"
"github.com/labring/sealos/pkg/apply"
"github.com/labring/sealos/pkg/apply/processor"
"github.com/labring/sealos/pkg/buildah"
"github.com/labring/sealos/pkg/utils/iputils"
"github.com/labring/sealos/pkg/utils/logger"
)
var exampleRun = `
create cluster to your baremetal server, appoint the iplist:
sealos run labring/kubernetes:v1.24.0 --masters 192.168.0.2,192.168.0.3,192.168.0.4 \
--nodes 192.168.0.5,192.168.0.6,192.168.0.7 --passwd xxx
multi image:
sealos run labring/kubernetes:v1.24.0 calico:v3.24.1 \
--masters 192.168.64.2,192.168.64.22,192.168.64.20 --nodes 192.168.64.21,192.168.64.19
Specify server InfraSSH port :
All servers use the same InfraSSH port (default port: 22)：
sealos run labring/kubernetes:v1.24.0 --masters 192.168.0.2,192.168.0.3,192.168.0.4 \
--nodes 192.168.0.5,192.168.0.6,192.168.0.7 --port 24 --passwd xxx
Different InfraSSH port numbers exist：
sealos run labring/kubernetes:v1.24.0 --masters 192.168.0.2,192.168.0.3:23,192.168.0.4:24 \
--nodes 192.168.0.5:25,192.168.0.6:25,192.168.0.7:27 --passwd xxx
Custom VIP kubernetes cluster:
sealos run -e defaultVIP=10.103.97.2 labring/kubernetes:v1.24.0 --masters 192.168.0.2,192.168.0.3,192.168.0.4 \
--nodes 192.168.0.5,192.168.0.6,192.168.0.7 --passwd xxx
Single kubernetes cluster：
sealos run labring/kubernetes:v1.24.0 --single
create a cluster with custom environment variables:
sealos run -e DashBoardPort=8443 mydashboard:latest --masters 192.168.0.2,192.168.0.3,192.168.0.4 \
--nodes 192.168.0.5,192.168.0.6,192.168.0.7 --passwd xxx
`
func newRunCmd() *cobra.Command {
runArgs := &apply.RunArgs{
Cluster: &apply.Cluster{},
SSH: &apply.SSH{},
}
var runSingle bool
var transport string
var runCmd = &cobra.Command{
Use: "run",
Short: "Run cloud native applications with ease, with or without a existing cluster",
Long: `sealos run labring/kubernetes:v1.24.0 --masters [arg] --nodes [arg]`,
Example: exampleRun,
RunE: func(cmd *cobra.Command, args []string) error {
if runSingle {
addr, _ := iputils.ListLocalHostAddrs()
runArgs.Masters = iputils.LocalIP(addr)
}
images, err := args2Images(args, transport)
if err != nil {
return err
}
applier, err := apply.NewApplierFromArgs(images, runArgs)
if err != nil {
return err
}
return applier.Apply()
},
PreRunE: func(cmd *cobra.Command, args []string) error {
if err := buildah.ValidateTransport(transport); err != nil {
return err
}
return nil
},
PostRun: func(cmd *cobra.Command, args []string) {
logger.Info(getContact())
},
}
runArgs.RegisterFlags(runCmd.Flags())
runCmd.Flags().BoolVar(&runSingle, "single", false, "run cluster in single mode")
runCmd.Flags().BoolVarP(&processor.ForceOverride, "force", "f", false, "force override app in this cluster")
runCmd.Flags().StringVarP(&transport, "transport", "t", buildah.OCIArchive,
fmt.Sprintf("load image transport from tar archive file.(optional value: %s, %s)", buildah.OCIArchive, buildah.DockerArchive))
return runCmd
}
func init() {
rootCmd.AddCommand(newRunCmd())
}
func args2Images(args []string, transport string) ([]string, error) {
var images []string
bder, err := buildah.New("")
if err != nil {
return images, err
}
for _, arg := range args {
if strings.HasSuffix(arg, ".tar") || strings.HasSuffix(arg, ".gz") {
id, err := bder.Load(arg, transport)
if err != nil {
return images, err
}
images = append(images, id)
} else {
images = append(images, arg)
}
}
return images, nil
}
// Copyright © 2021 Alibaba Group Holding Ltd.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
package apply
import (
"fmt"
"os"
"path/filepath"
"strconv"
"github.com/labring/sealos/pkg/apply/applydrivers"
"github.com/labring/sealos/pkg/clusterfile"
"github.com/labring/sealos/pkg/constants"
"github.com/labring/sealos/pkg/runtime"
"github.com/labring/sealos/pkg/ssh"
v2 "github.com/labring/sealos/pkg/types/v1beta1"
"github.com/labring/sealos/pkg/utils/iputils"
"github.com/labring/sealos/pkg/utils/logger"
stringsutil "github.com/labring/sealos/pkg/utils/strings"
)
type ClusterArgs struct {
cluster *v2.Cluster
hosts []v2.Host
clusterName string
}
func NewClusterFromArgs(imageName []string, args *RunArgs) ([]interface{}, error) {
cluster := initCluster(args.ClusterName)
c := &ClusterArgs{
clusterName: args.ClusterName,
cluster: cluster,
}
if err := c.SetClusterRunArgs(imageName, args); err != nil {
return nil, err
}
kubeadmcfg := &runtime.KubeadmConfig{}
if err := kubeadmcfg.Merge(""); err != nil {
return nil, err
}
// todo: only generate configurations of the corresponding components by passing parameters
return []interface{}{c.cluster,
kubeadmcfg.InitConfiguration,
kubeadmcfg.ClusterConfiguration,
kubeadmcfg.JoinConfiguration,
kubeadmcfg.KubeProxyConfiguration,
kubeadmcfg.KubeletConfiguration,
}, nil
}
func NewApplierFromArgs(imageName []string, args *RunArgs) (applydrivers.Interface, error) {
clusterPath := constants.Clusterfile(args.ClusterName)
cf := clusterfile.NewClusterFile(clusterPath,
clusterfile.WithCustomConfigFiles(args.CustomConfigFiles),
clusterfile.WithCustomEnvs(args.CustomEnv),
)
err := cf.Process()
if err != nil && err != clusterfile.ErrClusterFileNotExists {
return nil, err
}
cluster := cf.GetCluster()
if cluster == nil {
logger.Debug("creating new cluster")
cluster = initCluster(args.ClusterName)
} else {
cluster = cluster.DeepCopy()
}
c := &ClusterArgs{
clusterName: cluster.Name,
cluster: cluster,
}
if err = c.SetClusterRunArgs(imageName, args); err != nil {
return nil, err
}
return applydrivers.NewDefaultApplier(c.cluster, cf, imageName)
}
func NewApplierFromFile(path string, args *Args) (applydrivers.Interface, error) {
if !filepath.IsAbs(path) {
pa, err := os.Getwd()
if err != nil {
return nil, err
}
path = filepath.Join(pa, path)
}
Clusterfile := clusterfile.NewClusterFile(path,
clusterfile.WithCustomValues(args.Values),
clusterfile.WithCustomSets(args.Sets),
clusterfile.WithCustomEnvs(args.CustomEnv),
clusterfile.WithCustomConfigFiles(args.CustomConfigFiles),
)
if err := Clusterfile.Process(); err != nil {
return nil, err
}
cluster := Clusterfile.GetCluster()
if cluster.Name == "" {
return nil, fmt.Errorf("cluster name cannot be empty, make sure %s file is correct", path)
}
localpath := constants.Clusterfile(cluster.Name)
cf := clusterfile.NewClusterFile(localpath)
err := cf.Process()
if err != nil && err != clusterfile.ErrClusterFileNotExists {
return nil, err
}
currentCluster := cf.GetCluster()
return &applydrivers.Applier{
ClusterDesired: cluster,
ClusterFile: Clusterfile,
ClusterCurrent: currentCluster,
RunNewImages: nil,
}, nil
}
func (r *ClusterArgs) SetClusterRunArgs(imageList []string, args *RunArgs) error {
if args.Cluster.ClusterName == "" {
return fmt.Errorf("cluster name can not be empty")
}
//the first run check
if r.cluster.CreationTimestamp.IsZero() {
if len(imageList) == 0 {
return fmt.Errorf("image can not be empty")
}
if len(args.Cluster.Masters) == 0 {
return fmt.Errorf("master ip(s) must specified")
}
} else {
if r.cluster.Status.Phase != v2.ClusterSuccess {
return fmt.Errorf("cluster status is not %s", v2.ClusterSuccess)
}
}
if err := PreProcessIPList(args.Cluster); err != nil {
return err
}
if args.fs != nil {
if args.fs.Changed("env") || len(r.cluster.Spec.Env) == 0 {
r.cluster.Spec.Env = make([]string, len(args.CustomEnv))
copy(r.cluster.Spec.Env, args.CustomEnv)
}
if args.fs.Changed("cmd") || len(r.cluster.Spec.Command) == 0 {
r.cluster.Spec.Command = make([]string, len(args.CustomCMD))
copy(r.cluster.Spec.Command, args.CustomCMD)
}
if args.fs.Changed("user") || r.cluster.Spec.SSH.User == "" {
r.cluster.Spec.SSH.User = args.SSH.User
}
if args.fs.Changed("pk") || r.cluster.Spec.SSH.Pk == "" {
r.cluster.Spec.SSH.Pk = args.SSH.Pk
}
if args.fs.Changed("pk-passwd") || r.cluster.Spec.SSH.PkPasswd == "" {
r.cluster.Spec.SSH.PkPasswd = args.SSH.PkPassword
}
if args.fs.Changed("port") || r.cluster.Spec.SSH.Port == 0 {
r.cluster.Spec.SSH.Port = args.SSH.Port
}
if args.fs.Changed("passwd") || r.cluster.Spec.SSH.Passwd == "" {
r.cluster.Spec.SSH.Passwd = args.SSH.Password
}
}
r.cluster.SetNewImages(imageList)
masters := stringsutil.SplitRemoveEmpty(args.Cluster.Masters, ",")
nodes := stringsutil.SplitRemoveEmpty(args.Cluster.Nodes, ",")
r.hosts = []v2.Host{}
clusterSSH := r.cluster.GetSSH()
sshClient := ssh.NewSSHClient(&clusterSSH, true)
if len(masters) > 0 {
r.setHostWithIpsPort(masters, []string{v2.MASTER, GetHostArch(sshClient, masters[0])})
}
if len(nodes) > 0 {
r.setHostWithIpsPort(nodes, []string{v2.NODE, GetHostArch(sshClient, nodes[0])})
}
r.cluster.Spec.Hosts = append(r.cluster.Spec.Hosts, r.hosts...)
logger.Debug("cluster info: %v", r.cluster)
return nil
}
func (r *ClusterArgs) SetClusterResetArgs(args *ResetArgs) error {
if args.Cluster.ClusterName == "" {
return fmt.Errorf("cluster name can not be empty")
}
if err := PreProcessIPList(args.Cluster); err != nil {
return err
}
if args.fs != nil {
if args.fs.Changed("user") || r.cluster.Spec.SSH.User == "" {
r.cluster.Spec.SSH.User = args.SSH.User
}
if args.fs.Changed("pk") || r.cluster.Spec.SSH.Pk == "" {
r.cluster.Spec.SSH.Pk = args.SSH.Pk
}
if args.fs.Changed("pk-passwd") || r.cluster.Spec.SSH.PkPasswd == "" {
r.cluster.Spec.SSH.PkPasswd = args.SSH.PkPassword
}
if args.fs.Changed("port") || r.cluster.Spec.SSH.Port == 0 {
r.cluster.Spec.SSH.Port = args.SSH.Port
}
if args.fs.Changed("passwd") || r.cluster.Spec.SSH.Passwd == "" {
r.cluster.Spec.SSH.Passwd = args.SSH.Password
}
}
if len(args.Cluster.Masters) > 0 {
masters := stringsutil.SplitRemoveEmpty(args.Cluster.Masters, ",")
nodes := stringsutil.SplitRemoveEmpty(args.Cluster.Nodes, ",")
r.hosts = []v2.Host{}
clusterSSH := r.cluster.GetSSH()
sshClient := ssh.NewSSHClient(&clusterSSH, true)
r.setHostWithIpsPort(masters, []string{v2.MASTER, GetHostArch(sshClient, masters[0])})
if len(nodes) > 0 {
r.setHostWithIpsPort(nodes, []string{v2.NODE, GetHostArch(sshClient, nodes[0])})
}
r.cluster.Spec.Hosts = r.hosts
}
logger.Debug("cluster info: %v", r.cluster)
return nil
}
func (r *ClusterArgs) setHostWithIpsPort(ips []string, roles []string) {
defaultPort := strconv.Itoa(int(r.cluster.Spec.SSH.Port))
hostMap := map[string]*v2.Host{}
for i := range ips {
ip, port := iputils.GetHostIPAndPortOrDefault(ips[i], defaultPort)
socket := fmt.Sprintf("%s:%s", ip, port)
if stringsutil.In(socket, r.cluster.GetAllIPS()) {
continue
}
if _, ok := hostMap[port]; !ok {
hostMap[port] = &v2.Host{IPS: []string{socket}, Roles: roles}
continue
}
hostMap[port].IPS = append(hostMap[port].IPS, socket)
}
_, master0Port := iputils.GetHostIPAndPortOrDefault(ips[0], defaultPort)
for port, host := range hostMap {
host.IPS = removeIPListDuplicatesAndEmpty(host.IPS)
if port == master0Port && stringsutil.InList(v2.Master, roles) {
r.hosts = append([]v2.Host{*host}, r.hosts...)
continue
}
r.hosts = append(r.hosts, *host)
}
}
/*
Copyright 2022 cuisongliu@qq.com.
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*/
package apply
import (
"fmt"
"path"
"github.com/spf13/pflag"
"github.com/labring/sealos/pkg/constants"
)
type Cluster struct {
Masters string
Nodes string
ClusterName string
}
func (c *Cluster) RegisterFlags(fs *pflag.FlagSet, verb, action string) {
fs.StringVar(&c.Masters, "masters", "", fmt.Sprintf("masters to %s", verb))
fs.StringVar(&c.Nodes, "nodes", "", fmt.Sprintf("nodes to %s", verb))
fs.StringVar(&c.ClusterName, "cluster", "default", fmt.Sprintf("name of cluster to applied %s action", action))
}
type SSH struct {
User string
Password string
Pk string
PkPassword string
Port uint16
}
func (s *SSH) RegisterFlags(fs *pflag.FlagSet) {
fs.StringVarP(&s.User, "user", "u", "", "username to authenticate as")
fs.StringVarP(&s.Password, "passwd", "p", "", "use given password to authenticate with")
fs.StringVarP(&s.Pk, "pk", "i", path.Join(constants.GetHomeDir(), ".ssh", "id_rsa"),
"selects a file from which the identity (private key) for public key authentication is read")
fs.StringVar(&s.PkPassword, "pk-passwd", "", "passphrase for decrypting a PEM encoded private key")
fs.Uint16Var(&s.Port, "port", 22, "port to connect to on the remote host")
}
type RunArgs struct {
*Cluster
*SSH
CustomEnv []string
CustomCMD []string
CustomConfigFiles []string
fs *pflag.FlagSet
}
func (arg *RunArgs) RegisterFlags(fs *pflag.FlagSet) {
arg.Cluster.RegisterFlags(fs, "run with", "run")
arg.SSH.RegisterFlags(fs)
fs.StringSliceVarP(&arg.CustomEnv, "env", "e", []string{}, "environment variables to set during command execution")
fs.StringSliceVar(&arg.CustomCMD, "cmd", []string{}, "override CMD directive in images")
fs.StringSliceVar(&arg.CustomConfigFiles, "config-file", []string{}, "path of custom config files, to use to replace the resource")
arg.fs = fs
}
type Args struct {
Values []string
Sets []string
CustomEnv []string
CustomConfigFiles []string
}
func (arg *Args) RegisterFlags(fs *pflag.FlagSet) {
fs.StringSliceVar(&arg.Values, "values", []string{}, "values file to apply into Clusterfile")
fs.StringSliceVar(&arg.Sets, "set", []string{}, "set values on the command line")
fs.StringSliceVar(&arg.CustomEnv, "env", []string{}, "environment variables to set during command execution")
fs.StringSliceVar(&arg.CustomConfigFiles, "config-file", []string{}, "path of custom config files, to use to replace the resource")
}
type ResetArgs struct {
*Cluster
*SSH
fs *pflag.FlagSet
}
func (arg *ResetArgs) RegisterFlags(fs *pflag.FlagSet) {
arg.Cluster.RegisterFlags(fs, "be reset", "reset")
arg.SSH.RegisterFlags(fs)
arg.fs = fs
}
type ScaleArgs struct {
*Cluster
}
func (arg *ScaleArgs) RegisterFlags(fs *pflag.FlagSet, verb, action string) {
arg.Cluster.RegisterFlags(fs, verb, action)
}
