05903nam 2200673 450 991015195940332120221206101849.01-62705-983-010.2200/S00739ED1V01Y201610CNT017(CKB)3710000000953581(MiAaPQ)EBC4744544(CaBNVSL)swl00406951(OCoLC)963953310(IEEE)7748634(MOCL)201610CNT017(EXLCZ)99371000000095358120161205d2017 fy 0engurcnu||||||||rdacontentrdamediardacarrierAdvances in multi-channel resource allocation throughput, delay, and complexity /Bo Ji, Xiaojun Lin, Ness B. Shroff[San Rafael, California] :Morgan & Claypool,2017.1 online resource (132 pages) illustrations (some color)Synthesis lectures on communication networks,1935-4193 ;# 17Part of: Synthesis digital library of engineering and computer science.1-62705-461-8 Includes bibliographical references (pages 103-114).1. Overview -- 2. Intra-cell scheduling -- 2.1 Introduction -- 2.2 A simple system model -- 2.3 Pitfalls of the classical MaxWeight policy -- 2.4 Queue-length-based approaches -- 2.5 Delay-based approaches -- 2.6 Intuition of achieving optimality -- 2.7 Rate-function delay optimality -- 2.7.1 Assumptions on the arrival processes -- 2.7.2 Upper bound on the delay rate-function -- 2.7.3 Sufficient condition of rate-function delay optimality -- 2.7.4 Dominance property: frame-based scheduling and perfect matching -- 2.7.5 Vector matching in bipartite graphs -- 2.7.6 Proof sketch of rate-function delay optimality -- 2.8 Throughput optimality -- 2.8.1 Optimal throughput region -- 2.8.2 Sufficient condition of throughput optimality -- 2.9 Scheduling policies -- 2.9.1 Rate-function delay-optimal policies (DWM and DWM-n) -- 2.9.2 Throughput-optimal policies (DWM and d-MWS) -- 2.9.3 Low-complexity hybrid policies -- 2.10 Near-optimal delay rate-function -- 2.10.1 Delay-based server-side greedy -- 2.10.2 Main result and intuition -- 2.10.3 Equivalence property: delay-based queue-side-greedy -- 2.11 Simulations -- 2.12 Conclusion -- 3. Network-wide scheduling -- 3.1 Introduction -- 3.2 Single-channel solutions based on MaxWeight -- 3.2.1 A simple network model -- 3.2.2 The MaxWeight algorithm -- 3.2.3 Low-complexity approximations to MaxWeight -- 3.2.4 Single-channel CSMA algorithms -- 3.3 Using multiple channels -- 3.3.1 Independent CSMA chains across channels -- 3.3.2 Complementary schedules across channels: a departure from -- MaxWeight -- 3.3.3 What to do if there is only one physical channel? -- 3.3.4 The notion of delay -- 3.3.5 Utility-maximization vs. throughput-maximization -- 3.4 Multi-channel CSMA algorithm -- 3.5 throughput/delay/complexity analysis -- 3.5.1 Utility optimality -- 3.5.2 Delay performance -- 3.5.3 Computational complexity and communication overhead -- 3.5.4 VMC-CSMA under exogenous packet arrivals -- 3.6 Implementation -- 3.7 Performance evaluation -- 3.8 Inter-cell coordination in OFDM systems -- 3.8.1 Model for an OFDM multi-cell system -- 3.8.2 Distributed algorithms based on multi-channel Gibbs sampling -- 3.9 Conclusion -- 3.10 Additional notes -- Bibliography -- Authors' biographies.The last decade has seen an unprecedented growth in the demand for wireless services. These services are fueled by applications that often require not only high data rates, but also very low latency to function as desired. However, as wireless networks grow and support increasingly large numbers of users, these control algorithms must also incur only low complexity in order to be implemented in practice. Therefore, there is a pressing need to develop wireless control algorithms that can achieve both high throughput and low delay, but with low-complexity operations. While these three performance metrics, i.e., throughput, delay, and complexity, are widely acknowledged as being among the most important for modern wireless networks, existing approaches often have had to sacrifice a subset of them in order to optimize the others, leading to wireless resource allocation algorithms that either suffer poor performance or are difficult to implement. In contrast, the recent results presented in this book demonstrate that, by cleverly taking advantage of multiple physical or virtual channels, one can develop new low-complexity algorithms that attain both provably high throughput and provably low delay. The book covers both the intra-cell and network-wide settings. In each case, after the pitfalls of existing approaches are examined, new systematic methodologies are provided to develop algorithms that perform provably well in all three dimensions.Synthesis digital library of engineering and computer science.Synthesis lectures on communication networks ;# 17.1935-4193Radio resource management (Wireless communications)multi-channelwireless networksresource allocationschedulingutility maximizationthroughputdelaylow-complexityperformance guaranteeCSMARadio resource management (Wireless communications)384.54524Ji Bo1982-,1264539Lin Xiaojun(Electrical engineer),Shroff NessCaBNVSLCaBNVSLCaBNVSLBOOK9910151959403321Advances in multi-channel resource allocation2965166UNINA11816nam 2200553 450 991063773950332120230424103558.01-4842-9026-710.1007/978-1-4842-9026-2(MiAaPQ)EBC7164105(Au-PeEL)EBL7164105(CKB)25849085000041(OCoLC)1356574762(OCoLC-P)1356574762(CaSebORM)9781484290262(EXLCZ)992584908500004120230424d2022 uy 0engurcnu||||||||txtrdacontentcrdamediacrrdacarrierKubernetes programming with Go programming Kubernetes clients and operators using Go and the Kubernetes API /Philippe MartinNew York, NY :Apress,[2022]©20221 online resource (326 pages)Includes index.Print version: Martin, Philippe Kubernetes Programming with Go Berkeley, CA : Apress L. P.,c2023 9781484290255 Intro -- Table of Contents -- About the Author -- About the Technical Reviewers -- Acknowledgments -- Introduction -- Chapter 1: Kubernetes API Introduction -- Kubernetes Platform at a Glance -- OpenAPI Specification -- Verbs and Kinds -- Group-Version-Resource -- Sub-resources -- Official API Reference Documentation -- The Deployment Documentation -- Operations Documentation -- The Pod Documentation -- One-Page Version of the Documentation -- Conclusion -- Chapter 2: Kubernetes API Operations -- Examining Requests -- Making Requests -- Using kubectl as a Proxy -- Creating a Resource -- Getting Information About a Resource -- Getting the List of Resources -- Cluster-wide -- In a Specific namespace -- Filtering the Result of a List -- Using Label Selectors -- Using Field Selectors -- Deleting a Resource -- Deleting a Collection of Resources -- Updating a Resource -- Managing Conflicts When Updating a Resource -- Using a Strategic Merge Patch to Update a Resource -- Patching Array Fields -- Special Directives -- replace Directive -- delete Directive -- deleteFromPrimitiveList Directive -- setElementOrder Directive -- Applying Resources Server-side -- Watching Resources -- Filtering During a Watch Session -- Watching After Listing Resources -- Restarting a watch Request -- Allowing Bookmarks to Efficiently Restart a watch Request -- Paginating Results -- Consistency of the Full List -- Detecting the Last Chunk -- Getting Results in Various Formats -- Getting Results as a Table -- Column Definitions -- Row Data -- Using the YAML Format -- Using the Protobuf Format -- Conclusion -- Chapter 3: Working with API Resources in Go -- API Library Sources and Import -- Content of a Package -- types.go -- register.go -- doc.go -- generated.pb.go and generated.proto -- types_swagger_doc_generated.go -- zz_generated.deepcopy.go -- Specific Content in core/v1.ObjectReference -- ResourceList -- Taint -- Toleration -- Well-Known Labels -- Writing Kubernetes Resources in Go -- Importing the Package -- The TypeMeta Fields -- The ObjectMeta Fields -- Name -- Namespace -- UID, ResourceVersion, and Generation -- Labels and Annotations -- OwnerReferences -- Setting APIVersion and Kind -- Setting Controller -- Setting BlockOwnerDeletion -- Spec and Status -- Comparison with Writing YAML Manifests -- A Complete Example -- Conclusion -- Chapter 4: Using Common Types -- Pointers -- Getting the Reference of a Value -- Dereferencing a Pointer -- Comparing Two Referenced Values -- Quantities -- Parsing a String as Quantity -- Using an inf.Dec as a Quantity -- Using a Scaled Integer as a Quantity -- Operations on Quantities -- IntOrString -- Time -- Factory Methods -- Operations on Time -- Conclusion -- Chapter 5: The API Machinery -- The Schema Package -- Scheme -- Initialization -- Mapping -- Conversion -- Adding Conversion Functions -- Converting -- Serialization -- JSON and YAML Serializer -- Protobuf Serializer -- Encoding and Decoding -- RESTMapper -- Kind to Resource -- Resource to Kind -- Finding Resources -- The DefaultRESTMapper Implementation -- Conclusion -- Chapter 6: The Client-go Library -- Connecting to the Cluster -- In-cluster Configuration -- Out-of-Cluster Configuration -- From kubeconfig in Memory -- From a kubeconfig on Disk -- From a Personalized kubeconfig -- From Several kubeconfig Files -- Overriding kubeconfig with CLI Flags -- Getting a Clientset -- Using the Clientset -- Examining the Requests -- Creating a Resource -- Getting Information About a Resource -- Getting List of Resources -- Filtering the Result of a List -- Setting LabelSelector Using the Labels Package -- Using Requirements -- Parsing a LabelSelector String -- Using a Set of Key-value Pairs.Setting Fieldselector Using the Fields Package -- Assembling One Term Selectors -- Parsing a FieldSelector String -- Using a Set of Key-Value Pairs -- Deleting a Resource -- Deleting a Collection of Resources -- Updating a Resource -- Using a Strategic Merge Patch to Update a Resource -- Applying Resources Server-side with Patch -- Server-side Apply Using Apply Configurations -- Building an ApplyConfiguration from Scratch -- Building an ApplyConfiguration from an Existing Resource -- Watching Resources -- Errors and Statuses -- Definition of the metav1.Status Structure -- Error Returned by Clientset Operations -- RESTClient -- Building the Request -- Executing the Request -- Exploiting the Result -- Getting Result as a Table -- Discovery Client -- RESTMapper -- PriorityRESTMapper -- DeferredDiscoveryRESTMapper -- Conclusion -- Chapter 7: Testing Applications Using Client-go -- Fake Clientset -- Checking the Result of the Function -- Reacting to Actions -- Checking the Actions -- Fake REST Client -- FakeDiscovery Client -- Stubbing the ServerVersion -- Actions -- Mocking Resources -- Conclusion -- Chapter 8: Extending Kubernetes API with Custom Resources Definitions -- Performing Operations in Go -- The CustomResourceDefinition in Detail -- Naming the Resource -- Definition of the Resource Versions -- Converting Between Versions -- Schema of the Resource -- Deploying a Custom Resource Definition -- Additional Printer Columns -- Conclusion -- Chapter 9: Working with Custom Resources -- Generating a Clientset -- Using deepcopy-gen -- Installing deepcopy-gen -- Adding Annotations -- Running deepcopy-gen -- Using client-gen -- Installing client-go -- Adding Annotations -- Adding AddToScheme Function -- Running client-go -- Using the Generated Clientset -- Using the Generated fake Clientset -- Using the Unstructured Package and Dynamic Client.The Unstructured Type -- Getters and Setters to Access TypeMeta Fields -- Getters and Setters to Access ObjectMeta Fields -- Methods for Creating and Converting -- Helpers to Access Non-meta Fields -- Example -- The UnstructuredList Type -- Getters and Setters to Access TypeMeta Fields -- Getters and Setters to Access ListMeta Fields -- Methods for Creating and Converting -- Converting Between Typed and Unstructured Objects -- The Dynamic Client -- Getting the dynamic Client -- Working with the dynamic Client -- Example -- The fake dynamic Client -- Conclusion -- Chapter 10: Writing Operators with the Controller-Runtime Library -- The Manager -- The Controller -- Creating a Controller -- Watching Resources -- A First Example -- Using the Controller Builder -- A Second Example Using the ControllerBuilder -- Injecting Manager Resources into the Reconciler -- Passing the Values When Creating the Reconciler Structure -- Using Injectors -- Using the Client -- Getting Information About a Resource -- Listing Resources -- Creating a Resource -- Deleting a Resource -- Deleting a Collection of Resources -- Updating a Resource -- Patching a Resource -- Server-side Apply -- Strategic Merge Patch -- Merge Patch -- Updating the Status of a Resource -- Patching the Status of a Resource -- Logging -- Verbosity -- Predefined Values -- Logger Name -- Getting the Logger from Context -- Events -- Conclusion -- Chapter 11: Writing the Reconcile Loop -- Writing the Reconcile Function -- Checking Whether the Resource Exists -- Implementing the Reconciled Resource -- Simple Implementation Example -- Conclusion -- Chapter 12: Testing the Reconcile Loop -- The envtest Package -- Installing envtest Binaries -- Using envtest -- Defining a ginkgo Suite -- Writing the Tests -- Test 1 -- Test 2 -- Test 3 -- Test 4 -- Conclusion -- Chapter 13: Creating an Operator with Kubebuilder.Installing Kubebuilder -- Creating a Project -- Adding a Custom Resource to the Project -- Building and Deploying Manifests -- Running the Manager Locally -- Personalizing the Custom Resource -- Editing the Go Structures -- Enabling the Status Subresource -- Defining Printer Columns -- Regenerating the Files -- Implementing the Reconcile Function -- Adding RBAC Annotations -- Deploying the Operator on the Cluster -- Creating a New Version of the Resource -- Defining a New Version -- Implementing Hub and Convertible -- Setting Up the webhook -- Updating kustomization Files -- Using Various Versions -- Conclusion -- Index.This book begins by introducing the structure of the Kubernetes API and which operations it serves. Following chapters demonstrate how to write native Kubernetes resources definitions using Go structures defined in the API and API Machinery libraries. Miscellaneous utilities are described to help you work with different resource fields and to convert your resource definitions to or from YAML or JSON. Next, you will learn how to interact with the Kubernetes API server to create, delete, update, and monitor resources in a cluster using the client-go library. A complete chapter is devoted to tools provided to test your programs using the client-go library. An example follows to wrap up the first part of the book, describing how to write a kubectl plugin. Next, you will learn how to extend the Kubernetes API using Custom Resource Definitions, and how to write Kubernetes resources in a generic way as well as how to create your own resources using the unstructured concept. The next chapters delve into the controller-runtime library, useful for extending Kubernetes by writing operators, and the kubebuilder framework, which leverages this library, to help you start writing operators in minutes. After reading this book, you will have a deep understanding of the Kubernetes API's structure and how Kubernetes resources are organized within it, and have at your disposal a complete toolbox to help you write Kubernetes clients and operators. What You Will Learn Understand how the Kubernetes API and its resources are organized Write Kubernetes resources in Go Create resources in a cluster Leverage your newly-gained knowledge to write Kubernetes clients and operators Who is this Book for: Software engineers and (Site Reliability Engineers) SREs wishing to write Kubernetes clients and operators using the Go language.Go (Computer program language)Software container technologiesApplication softwareDevelopmentGo (Computer program language)Software container technologies.Application softwareDevelopment.005.3Martin Philippe200316MiAaPQMiAaPQMiAaPQBOOK9910637739503321Kubernetes Programming with Go3000254UNINA