Merge branch 'rackerlabs:main' into update-swift-docs

.github/workflows/release-octavia-ovn.yml

@@ -15,10 +15,12 @@ on:
       pluginTag:
         description: 'Set plugin version'
         required: true
-        default: '5.0.0'
+        default: '7.0.0'
         type: choice
         options:
           - '5.0.0'
+          - '6.0.0'
+          - '7.0.0'
 
 # Defines two custom environment variables for the workflow. These are used for the Container registry domain, and a name for the Docker image that this workflow builds.
 env:

docs/accelerated-computing-overview.md

@@ -0,0 +1,183 @@
+# What is Accelerated Computing?
+
+![Rackspace Cloud Software](assets/images/ospc_flex_logo_red.svg){ align=left : style="max-width:175px" }
+
+## Overview
+
+Accelerated computing uses specialized hardware called accelerators, such as the following:
+
+* Graphics Processing Units ([GPUs](https://en.wikipedia.org/wiki/Graphics_processing_unit))
+* Neural Processing Units ([NPUs](https://support.microsoft.com/en-us/windows/all-about-neural-processing-units-npus-e77a5637-7705-4915-96c8-0c6a975f9db4))
+* Smart Network Interface Cards([Smart NICs](https://codilime.com/blog/what-are-smartnics-the-different-types-and-features/))
+* Tensor Processing Units ([TPUs](https://en.wikipedia.org/wiki/Tensor_Processing_Unit))
+* Field Programmable Gate Arrays ([FPGAs](https://en.wikipedia.org/wiki/Field-programmable_gate_array))
+
+These accelerators are used to perform computations faster than traditional CPUs alone because they are designed to handle highly parallel, complex, or data-intensive tasks more efficiently. This makes them ideal for applications like machine learning, scientific simulations, graphics rendering, and big data processing.
+
+## Benefits
+
+* **Parallel Processing**: Accelerators can perform multiple calculations simultaneously. For example, GPUs have thousands of
+  cores, allowing them to execute many tasks at once, which is ideal for matrix calculations common in machine learning.
+
+* **Optimized Architectures**: Each type of accelerator is tailored to specific tasks. GPUs are optimized for floating-point
+  operations, making them well-suited for image processing and deep learning. TPUs are specifically designed by Google for
+  neural network computations, while FPGAs can be customized to accelerate a variety of applications.
+
+* **Energy and Cost Efficiency**: Accelerators can reduce energy usage and costs by performing computations faster, which is
+  particularly important in data centers and high-performance computing environments.
+
+* **Enhanced Performance in AI and Data-Intensive Workloads**: Accelerated computing has become foundational for AI and machine
+  learning, where training models on large datasets can take days or weeks without specialized hardware.
+
+### GPUs
+
+GPUs are widely used as accelerators for a variety of tasks, especially those involving high-performance computing, artificial intelligence, and deep learning. Originally designed for rendering graphics in video games and multimedia applications, GPUs have evolved into versatile accelerators due to their highly parallel architecture. Here’s how GPUs act as effective accelerators:
+
+  1. **Massively Parallel Architecture**: With thousands of cores, GPUs excel in parallel tasks, such as training neural networks,
+     which require numerous simultaneous operations like matrix multiplications.
+
+  2. **High Throughput for Large Data**: GPUs deliver superior throughput for processing large datasets, making them ideal for
+     applications in image/video processing, data analytics, and simulations (e.g., climate modeling).
+
+  3. **Efficient for Deep Learning and AI**: GPUs handle deep learning tasks, especially matrix calculations, much faster than
+     CPUs. Popular frameworks like TensorFlow and PyTorch offer GPU support for both training and inference.
+
+  4. **Real-Time Processing**: GPUs enable low-latency processing for time-sensitive applications like autonomous driving and
+     real-time video analysis, where rapid decision-making is crucial.
+
+  5. **Accelerating Scientific Computing**: In scientific research, GPUs speed up computations for complex simulations in fields
+     like molecular dynamics, astrophysics, and genomics.
+
+  6. **AI Model Inference and Deployment**: Post-training, GPUs accelerate AI model inference for real-time predictions across
+     industries like healthcare, finance, and security.
+
+  7. **Software Ecosystem**: NVIDIA GPUs benefit from a robust ecosystem (e.g., CUDA, cuDNN) that supports AI, machine learning,
+     and scientific computing, enabling developers to fully harness GPU power.
+
+In summary, GPUs function as accelerators by leveraging their parallel processing capabilities and high computational power to speed up a range of data-intensive tasks. They are versatile tools, widely used across industries for tasks that require rapid, efficient processing of large volumes of data.
+
+### NPUs
+
+NPUs are specialized accelerators designed specifically to handle AI and deep learning tasks, especially neural network computations. They’re highly optimized for the types of mathematical operations used in AI, such as matrix multiplications and convolutions, making them particularly effective for tasks like image recognition, natural language processing, and other machine learning applications. Here’s how NPUs function as powerful accelerators:
+
+  1. **Optimized for Neural Network Operations**: NPUs excel at tensor operations and matrix multiplications, which are central to
+     neural networks, providing greater efficiency than CPUs or GPUs.
+
+  2. **Parallelized Processing**: With multiple cores optimized for parallel tasks, NPUs handle large datasets and complex
+     computations simultaneously, making them ideal for deep learning applications.
+
+  3. **Low Power Consumption**: NPUs are energy-efficient, making them well-suited for mobile and edge devices, such as
+     smartphones and IoT sensors, where power is limited.
+
+  4. **Faster Inference for Real-Time Apps**: NPUs accelerate AI model inference, enabling real-time applications like facial
+     recognition, voice assistants, and autonomous driving.
+
+  5. **Offloading from CPUs and GPUs**: By offloading neural network tasks, NPUs reduce the burden on CPUs and GPUs, improving
+     overall system performance, especially in multi-process environments.
+
+  6. **Wide Device Integration**: NPUs are increasingly integrated into various devices, from mobile phones (e.g., Apple’s Neural
+     Engine) to data centers (e.g., Google’s TPU), enabling AI in low-power and resource-constrained environments.
+
+In summary, NPUs are specialized accelerators that enhance AI processing efficiency, enabling faster and more accessible AI applications across a wide range of devices.
+
+### Smart NICs
+
+Smart NICs act as accelerators by offloading and accelerating network-related tasks, helping to improve the performance of servers in data centers, cloud environments, and high-performance computing applications. Unlike traditional NICs that only handle basic data transfer, Smart NICs have onboard processing capabilities, often including dedicated CPUs, FPGAs, or even GPUs, which enable them to process data directly on the card. Here’s how they function as powerful accelerators:
+
+  1. **Offloading Network Tasks**: Smart NICs offload tasks like packet processing, encryption, load balancing, and firewall
+     management, freeing the CPU to focus on application-specific computations.
+
+  2. **Accelerating Data Processing**: With built-in processing capabilities, Smart NICs handle tasks such as data encryption,
+     compression, and analysis, crucial for data-intensive environments like data centers.
+
+  3. **Programmable Logic (FPGA-Based NICs)**: Many Smart NICs use FPGAs, which can be reprogrammed for specific networking
+     functions, offering flexibility and adaptability to evolving network protocols.
+
+  4. **Enhanced Performance with RDMA**: By supporting Remote Direct Memory Access (RDMA), Smart NICs enable direct
+     memory-to-memory data transfers, reducing latency and improving throughput for latency-sensitive applications.
+
+  5. **Security Acceleration**: Smart NICs offload security functions like encryption, firewall management, and intrusion
+     detection, processing them in real-time to enhance network security without compromising performance.
+
+  6. **Data Center and Cloud Optimization**: In virtualized environments, Smart NICs offload and accelerate virtual network
+     functions (VNFs), reducing CPU load and improving resource utilization for cloud and data center applications.
+
+  7. **Accelerating Storage Networking**: Smart NICs accelerate storage networking tasks, such as NVMe-oF, for faster remote
+     storage access and improved performance in data-heavy applications.
+
+  8. **Edge Computing and IoT**: Smart NICs process data locally in edge devices, performing tasks like filtering, aggregation,
+     and compression to reduce latency and optimize data transfer.
+
+In summary, Smart NICs enhance system performance by offloading network and data processing tasks, enabling higher efficiency, lower latency, and improved scalability in data-intensive environments.
+
+### TPUs
+
+TPUs are specialized accelerators developed by Google to optimize and accelerate machine learning workloads, particularly for deep learning and neural network computations. Unlike general-purpose processors, TPUs are custom-designed to efficiently handle the massive amounts of matrix operations and tensor computations commonly required by machine learning algorithms, especially deep neural networks. Here’s how TPUs function as powerful accelerators:
+
+  1. **Matrix Multiplication Optimization**: TPUs accelerate matrix multiplications, essential for deep learning models, making
+     them much faster than CPUs or GPUs.
+
+  2. **Parallel Processing**: With a large number of cores, TPUs enable high levels of parallelism, allowing them to process
+     complex neural networks quickly.
+
+  3. **Energy Efficiency**: Designed to consume less power than CPUs and GPUs, TPUs reduce energy costs, making them ideal for
+     large-scale data centers.
+
+  4. **High-Speed Memory Access**: TPUs use high-bandwidth memory (HBM) to quickly feed data to processing units, speeding up
+     training and inference.
+
+  5. **Performance for Training and Inference**: TPUs deliver low-latency performance for both model training and real-time
+     inference, critical for AI applications.
+
+  6. **TensorFlow Integration**: TPUs are tightly integrated with TensorFlow, offering optimized tools and functions for seamless
+     use within the framework.
+
+  7. **Scalability with TPU Pods**: TPU Pods in Google Cloud allow scaling processing power for massive datasets and
+     enterprise-level machine learning models.
+
+  8. **Optimized Data Types**: Using BFloat16, TPUs enable faster computation while maintaining model accuracy, reducing memory
+     and processing demands.
+
+  9. **Edge TPUs for IoT**: Edge TPUs provide low-power machine learning capabilities for edge and IoT devices, supporting
+     real-time AI tasks like image recognition.
+
+In summary, TPUs are custom-designed accelerators that significantly enhance the speed, efficiency, and scalability of machine learning tasks, particularly in large-scale and real-time AI applications.
+
+### FPGAs
+
+FPGAs are highly customizable accelerators that offer unique advantages for specialized computing tasks, especially in data-intensive fields such as machine learning, financial trading, telecommunications, and scientific research. FPGAs are programmable hardware that can be configured to perform specific functions with high efficiency, making them very versatile. Here’s how FPGAs function as powerful accelerators:
+
+  1. **Customizable Hardware**: Unlike fixed accelerators, FPGAs can be reprogrammed for specific tasks, allowing optimization for
+     workloads like data encryption, compression, or AI inference.
+
+  2. **High Parallelism**: FPGAs feature thousands of independent logic blocks, enabling parallel data processing, ideal for
+     applications like real-time signal processing and genomics.
+
+  3. **Low Latency & Predictability**: FPGAs provide extremely low latency and deterministic performance, crucial for real-time
+     applications like high-frequency trading.
+
+  4. **Energy Efficiency**: FPGAs are energy-efficient by utilizing only the necessary hardware resources for a task, making them
+     suitable for energy-sensitive environments like edge devices.
+
+  5. **Flexibility**: Reprogrammability allows FPGAs to adapt to evolving standards and algorithms, such as new networking
+     protocols or machine learning models.
+
+  6. **Machine Learning Inference**: FPGAs excel at AI inference tasks, providing low-latency, efficient processing for
+     applications like object detection and speech recognition.
+
+  7. **Custom Data Types**: FPGAs can handle specialized data formats to optimize memory and processing speed, ideal for
+     applications like AI with reduced-precision data.
+
+  8. **Hardware-Level Security**: FPGAs can implement custom cryptographic algorithms for secure communications or sensitive data
+     handling.
+
+  9. **Real-Time Signal Processing**: FPGAs are used in industries like telecommunications and aerospace for high-speed, real-time
+     signal processing in applications like radar and 5G.
+
+  10. **Edge Computing & IoT**: FPGAs are deployed in edge devices to perform local computations, such as sensor data processing
+      or on-device AI inference, reducing reliance on the cloud.
+
+  11. **Integration with Other Accelerators**: FPGAs can complement CPUs and GPUs in heterogeneous computing environments,
+      handling tasks like preprocessing or data compression while other accelerators manage complex workloads.
+
+In summary, FPGAs are versatile accelerators, offering customizable, energy-efficient hardware for high-speed, low-latency processing across various specialized applications, from signal processing to machine learning.

docs/openstack-quota.md

@@ -0,0 +1,29 @@
+# OpenStack Quotas
+
+To read more about Openstack quotas please visit the [upstream docs](https://docs.openstack.org/nova/rocky/admin/quotas.html).
+
+#### Viewing Your Quota
+
+You can view your quotas via Skyline or using the OpenStack CLI client.  The Skyline home page is the easiest way to view your quota limits and utilization in one place.
+![SkylineHome](./assets/images/SkylineHomeQuota.png)
+
+You can also view quota information using the OpenStack CLI, however, you'll need to use a couple of commands.<BR>
+Use the quota option to list all of your quota limits.
+
+```shell
+openstack quota show
+```
+
+![quota show](./assets/images/quota_show.png)
+
+The limits option returns quota limits along with utilization information for most services.
+
+```shell
+openstack limits show --absolute
+```
+
+![limits show](./assets/images/limits_show.png)
+
+#### Increasing Your Quota
+
+If you need to request a quota increase, please contact your Account Manager or navigate to the [MyCloud](https://mycloud.rackspace.com) portal, create a ticket, and select Account as the category.

docs/security-introduction.md

@@ -0,0 +1,65 @@
+# Genestack Secure Development Practices
+
+Genestack is a complete operation and deployment ecosystem for OpenStack services that heavily utilizes cloud native application like
+Kubernetes. While developing, publishing, deploying and running OpenStack services based on Genestack we aim to ensure that our engineering teams follow
+security best practices not just for OpenStack components but also for k8s and other cloud native applications used within the Genestack ecosystem.
+
+This security primer aims to outline layered security practices for Genestack, providing actionable security recommendations at every level to mitigate
+risks by securing infrastructure, platform, applications and data at each layer of the development process.
+This primer emphasizes secure development practices that complement Genestack's architecture and operational workflows.
+
+
+## Layered Security Approach
+
+Layered security ensures comprehensive protection against evolving threats by addressing risks at multiple levels. The approach applies security measures
+to both physical infrastructure and also provides security focus to the development of the application itself. The aim is to minimize a single point
+of failure compromising the entire system. This concept aligns with the cloud native environments by catagorizing security measures across the lifecycle and stack of the cloud native technologies.
+
+The development team follow a set of practices for Genestack: Rackspace OpenStack Software Development Life Cycle (Rax-O-SDLC). The SDLC practice aims to produce
+software that meets or exceeds customer expectation and reach completion within a time and cost estimate. SDLC process is divided into six distinct phases: `Scope`, `Implement`,
+`Document`, `Test`, `Deployment` and `Maintain`.
+
+For each of the above stages fall within the security guidelines from CNCF that models security into four distince phases.
+
+Security is then injected at each of these phases:
+
+1. **Develop:** Applying security principles during application development
+
+2. **Distribute:** Security practices to distribute code and artifacts
+
+3. **Deploy:** How to ensure security during application deployment
+
+4. **Runtime:** Best practices to secure infrastructure and interrelated components
+
+
+Lets look at it from OpenStack side of things. We want to see security across:
+
+1. **Infrastructure:** Both physical and virtual resources
+
+2. **Platform:** Services that support workloads
+
+3. **Applications:** Containerized workloads and instances that run the services
+
+4. **Data:** Security of data at rest and in transit
+
+
+CNCF defines its security principles as:
+
+1. Make security a design requirement
+
+2. Applying secure configuration has the best user experience
+
+3. Selecting insecure configuration is a conscious decision
+
+4. Transition from insecure to secure state is possible
+
+5. Secure defaults are inherited
+
+6. Exception lists have first class support
+
+7. Secure defaults protect against pervasive vulnerability exploits
+
+8. Security limitations of a system are explainable
+
+
+These guidelines can be adopted to have a secure foundation for Genestack based cloud.