zoukankan      html  css  js  c++  java
  • kubernetes Leader Election Example

    原文链接:https://sourcegraph.com/github.com/kubernetes/client-go@7f988d725c5d73e1cd4d7cc6ea7f964026035903/-/blob/examples/leader-election/main.go

    /*
    Copyright 2018 The Kubernetes Authors.
    
    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 main
    
    import (
        "context"
        "flag"
        "fmt"
        "log"
        "os"
        "os/signal"
        "strings"
        "syscall"
        "time"
    
        metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
        clientset "k8s.io/client-go/kubernetes"
        "k8s.io/client-go/rest"
        "k8s.io/client-go/tools/clientcmd"
        "k8s.io/client-go/tools/leaderelection"
        "k8s.io/client-go/tools/leaderelection/resourcelock"
        "k8s.io/client-go/transport"
        "k8s.io/klog"
    )
    
    func buildConfig(kubeconfig string) (*rest.Config, error) {
        if kubeconfig != "" {
            cfg, err := clientcmd.BuildConfigFromFlags("", kubeconfig)
            if err != nil {
                return nil, err
            }
            return cfg, nil
        }
    
        cfg, err := rest.InClusterConfig()
        if err != nil {
            return nil, err
        }
        return cfg, nil
    }
    
    func main() {
        klog.InitFlags(nil)
    
        var kubeconfig string
        var leaseLockName string
        var leaseLockNamespace string
        var id string
    
        flag.StringVar(&kubeconfig, "kubeconfig", "", "absolute path to the kubeconfig file")
        flag.StringVar(&id, "id", "", "the holder identity name")
        flag.StringVar(&leaseLockName, "lease-lock-name", "example", "the lease lock resource name")
        flag.StringVar(&leaseLockNamespace, "lease-lock-namespace", "default", "the lease lock resource namespace")
        flag.Parse()
    
        if id == "" {
            klog.Fatal("unable to get id (missing id flag).")
        }
    
        // leader election uses the Kubernetes API by writing to a
        // lock object, which can be a LeaseLock object (preferred),
        // a ConfigMap, or an Endpoints (deprecated) object.
        // Conflicting writes are detected and each client handles those actions
        // independently.
        config, err := buildConfig(kubeconfig)
        if err != nil {
            klog.Fatal(err)
        }
        client := clientset.NewForConfigOrDie(config)
    
        // we use the Lease lock type since edits to Leases are less common
        // and fewer objects in the cluster watch "all Leases".
        lock := &resourcelock.LeaseLock{
            LeaseMeta: metav1.ObjectMeta{
                Name:      leaseLockName,
                Namespace: leaseLockNamespace,
            },
            Client: client.CoordinationV1(),
            LockConfig: resourcelock.ResourceLockConfig{
                Identity: id,
            },
        }
    
        // use a Go context so we can tell the leaderelection code when we
        // want to step down
        ctx, cancel := context.WithCancel(context.Background())
        defer cancel()
    
        // use a client that will stop allowing new requests once the context ends
        config.Wrap(transport.ContextCanceller(ctx, fmt.Errorf("the leader is shutting down")))
    
        // listen for interrupts or the Linux SIGTERM signal and cancel
        // our context, which the leader election code will observe and
        // step down
        ch := make(chan os.Signal, 1)
        signal.Notify(ch, os.Interrupt, syscall.SIGTERM)
        go func() {
            <-ch
            log.Printf("Received termination, signaling shutdown")
            cancel()
        }()
    
        // start the leader election code loop
        leaderelection.RunOrDie(ctx, leaderelection.LeaderElectionConfig{
            Lock: lock,
            // IMPORTANT: you MUST ensure that any code you have that
            // is protected by the lease must terminate **before**
            // you call cancel. Otherwise, you could have a background
            // loop still running and another process could
            // get elected before your background loop finished, violating
            // the stated goal of the lease.
            ReleaseOnCancel: true,
            LeaseDuration:   60 * time.Second,
            RenewDeadline:   15 * time.Second,
            RetryPeriod:     5 * time.Second,
            Callbacks: leaderelection.LeaderCallbacks{
                OnStartedLeading: func(ctx context.Context) {
                    // we're notified when we start - this is where you would
                    // usually put your code
                    klog.Infof("%s: leading", id)
                },
                OnStoppedLeading: func() {
                    // we can do cleanup here, or after the RunOrDie method
                    // returns
                    klog.Infof("%s: lost", id)
                },
                OnNewLeader: func(identity string) {
                    // we're notified when new leader elected
                    if identity == id {
                        // I just got the lock
                        return
                    }
                    klog.Infof("new leader elected: %v", identity)
                },
            },
        })
    
        // because the context is closed, the client should report errors
        _, err = client.CoordinationV1().Leases(leaseLockNamespace).Get(leaseLockName, metav1.GetOptions{})
        if err == nil || !strings.Contains(err.Error(), "the leader is shutting down") {
            log.Fatalf("%s: expected to get an error when trying to make a client call: %v", id, err)
        }
    
        // we no longer hold the lease, so perform any cleanup and then
        // exit
        log.Printf("%s: done", id)
    }

    编译:

    # first terminal 
    go run *.go -kubeconfig=/my/config -logtostderr=true -id=1
    
    # second terminal 
    go run *.go -kubeconfig=/my/config -logtostderr=true -id=2
    
    # third terminal
    go run *.go -kubeconfig=/my/config -logtostderr=true -id=3
  • 相关阅读:
    记一次 contentInsetAdjustmentBehavior 引发的bug
    Android埋点技术概览
    Android开发快速入门iOS开发概览
    工作项目遇到的一些问题
    ruby操作项目.xcodeproj
    关于performSelector afterDelay:0 的使用
    谷歌Python代码风格指南 中文翻译
    最大子矩阵问题--悬线法dp
    tarjan
    SDU CSPT3模拟
  • 原文地址:https://www.cnblogs.com/wangjq19920210/p/14310218.html
Copyright © 2011-2022 走看看