diff options
Diffstat (limited to 'python-kopf.spec')
| -rw-r--r-- | python-kopf.spec | 610 |
1 files changed, 610 insertions, 0 deletions
diff --git a/python-kopf.spec b/python-kopf.spec new file mode 100644 index 0000000..b8059dd --- /dev/null +++ b/python-kopf.spec @@ -0,0 +1,610 @@ +%global _empty_manifest_terminate_build 0 +Name: python-kopf +Version: 1.36.0 +Release: 1 +Summary: Kubernetes Operator Pythonic Framework (Kopf) +License: MIT +URL: https://github.com/nolar/kopf +Source0: https://mirrors.nju.edu.cn/pypi/web/packages/51/1e/b31f321deca8f40219e03b707e9189e5d1b6258b2119b2e69fb6cde755f3/kopf-1.36.0.tar.gz +BuildArch: noarch + +Requires: python3-typing-extensions +Requires: python3-json-logger +Requires: python3-iso8601 +Requires: python3-click +Requires: python3-aiohttp +Requires: python3-pyyaml +Requires: python3-pyngrok +Requires: python3-oscrypto +Requires: python3-certbuilder +Requires: python3-certvalidator +Requires: python3-pykube-ng +Requires: python3-kubernetes +Requires: python3-uvloop + +%description +# Kubernetes Operator Pythonic Framework (Kopf) + +[](https://pypi.org/project/kopf/) +[](https://github.com/nolar/kopf/actions/workflows/thorough.yaml) +[](https://codecov.io/gh/nolar/kopf) +[](https://coveralls.io/github/nolar/kopf?branch=main) +[](https://lgtm.com/projects/g/nolar/kopf/alerts/) +[](https://lgtm.com/projects/g/nolar/kopf/context:python) +[](https://github.com/pre-commit/pre-commit) + +**Kopf** —Kubernetes Operator Pythonic Framework— is a framework and a library +to make Kubernetes operators development easier, just in a few lines of Python code. + +The main goal is to bring the Domain-Driven Design to the infrastructure level, +with Kubernetes being an orchestrator/database of the domain objects (custom resources), +and the operators containing the domain logic (with no or minimal infrastructure logic). + +The project was originally started as `zalando-incubator/kopf` in March 2019, +and then forked as `nolar/kopf` in August 2020: but it is the same codebase, +the same packages, the same developer(s). + + +## Documentation + +* https://kopf.readthedocs.io/ + + +## Features + +* Simple, but powerful: + * A full-featured operator in just 2 files: a `Dockerfile` + a Python file (*). + * Handling functions registered via decorators with a declarative approach. + * No infrastructure boilerplate code with K8s API communication. + * Both sync and async handlers, with sync ones being threaded under the hood. + * Detailed documentation with examples. +* Intuitive mapping of Python concepts to Kubernetes concepts and back: + * Marshalling of resources' data to the handlers' kwargs. + * Marshalling of handlers' results to the resources' statuses. + * Publishing of logging messages as Kubernetes events linked to the resources. +* Support anything that exists in K8s: + * Custom K8s resources. + * Builtin K8s resources (pods, namespaces, etc). + * Multiple resource types in one operator. + * Both cluster and namespaced operators. +* All the ways of handling that a developer can wish for: + * Low-level handlers for events received from K8s APIs "as is" (an equivalent of _informers_). + * High-level handlers for detected causes of changes (creation, updates with diffs, deletion). + * Handling of selected fields only instead of the whole objects (if needed). + * Dynamically generated or conditional sub-handlers (an advanced feature). + * Timers that tick as long as the resource exists, optionally with a delay since the last change. + * Daemons that run as long as the resource exists (in threads or asyncio-tasks). + * Validating and mutating admission webhook (with dev-mode tunneling). + * Live in-memory indexing of resources or their excerpts. + * Filtering with stealth mode (no logging): by arbitrary filtering functions, + by labels/annotations with values, presence/absence, or dynamic callbacks. + * In-memory all-purpose containers to store non-serializable objects for individual resources. +* Eventual consistency of handling: + * Retrying the handlers in case of arbitrary errors until they succeed. + * Special exceptions to request a special retry or to never retry again. + * Custom limits for the number of attempts or the time. + * Implicit persistence of the progress that survives the operator restarts. + * Tolerance to restarts and lengthy downtimes: handles the changes afterwards. +* Awareness of other Kopf-based operators: + * Configurable identities for different Kopf-based operators for the same resource kinds. + * Avoiding double-processing due to cross-pod awareness of the same operator ("peering"). + * Pausing of a deployed operator when a dev-mode operator runs outside of the cluster. +* Extra toolkits and integrations: + * Some limited support for object hierarchies with name/labels propagation. + * Friendly to any K8s client libraries (and is client agnostic). + * Startup/cleanup operator-level handlers. + * Liveness probing endpoints and rudimentary metrics exports. + * Basic testing toolkit for in-memory per-test operator running. + * Embeddable into other Python applications. +* Highly configurable (to some reasonable extent). + +(*) _Small font: two files of the operator itself, plus some amount of +deployment files like RBAC roles, bindings, service accounts, network policies +— everything needed to deploy an application in your specific infrastructure._ + + +## Examples + +See [examples](https://github.com/nolar/kopf/tree/main/examples) +for the examples of the typical use-cases. + +A minimalistic operator can look like this: + +```python +import kopf + +@kopf.on.create('kopfexamples') +def create_fn(spec, name, meta, status, **kwargs): + print(f"And here we are! Created {name} with spec: {spec}") +``` + +Numerous kwargs are available, such as `body`, `meta`, `spec`, `status`, +`name`, `namespace`, `retry`, `diff`, `old`, `new`, `logger`, etc: +see [Arguments](https://kopf.readthedocs.io/en/latest/kwargs/) + +To run a never-exiting function for every resource as long as it exists: + +```python +import time +import kopf + +@kopf.daemon('kopfexamples') +def my_daemon(spec, stopped, **kwargs): + while not stopped: + print(f"Object's spec: {spec}") + time.sleep(1) +``` + +Or the same with the timers: + +```python +import kopf + +@kopf.timer('kopfexamples', interval=1) +def my_timer(spec, **kwargs): + print(f"Object's spec: {spec}") +``` + +That easy! For more features, see the [documentation](https://kopf.readthedocs.io/). + + +## Usage + +Python 3.7+ is required: +[CPython](https://www.python.org/) and [PyPy](https://www.pypy.org/) +are officially supported and tested; other Python implementations can work too. + +We assume that when the operator is executed in the cluster, it must be packaged +into a docker image with a CI/CD tool of your preference. + +```dockerfile +FROM python:3.11 +ADD . /src +RUN pip install kopf +CMD kopf run /src/handlers.py --verbose +``` + +Where `handlers.py` is your Python script with the handlers +(see `examples/*/example.py` for the examples). + +See `kopf run --help` for other ways of attaching the handlers. + + +## Contributing + +Please read [CONTRIBUTING.md](https://github.com/nolar/kopf/blob/main/CONTRIBUTING.md) +for details on our process for submitting pull requests to us, and please ensure +you follow the [CODE_OF_CONDUCT.md](https://github.com/nolar/kopf/blob/main/CODE_OF_CONDUCT.md). + +To install the environment for the local development, +read [DEVELOPMENT.md](https://github.com/nolar/kopf/blob/main/DEVELOPMENT.md). + + +## Versioning + +We use [SemVer](http://semver.org/) for versioning. For the versions available, +see the [releases on this repository](https://github.com/nolar/kopf/releases). + + +## License + +This project is licensed under the MIT License — +see the [LICENSE](https://github.com/nolar/kopf/blob/main/LICENSE) file for details. + + +## Acknowledgments + +* Thanks to Zalando for starting this project in Zalando's Open-Source Incubator + in the first place. +* Thanks to [@side8](https://github.com/side8) and their [k8s-operator](https://github.com/side8/k8s-operator) + for inspiration. + + +%package -n python3-kopf +Summary: Kubernetes Operator Pythonic Framework (Kopf) +Provides: python-kopf +BuildRequires: python3-devel +BuildRequires: python3-setuptools +BuildRequires: python3-pip +%description -n python3-kopf +# Kubernetes Operator Pythonic Framework (Kopf) + +[](https://pypi.org/project/kopf/) +[](https://github.com/nolar/kopf/actions/workflows/thorough.yaml) +[](https://codecov.io/gh/nolar/kopf) +[](https://coveralls.io/github/nolar/kopf?branch=main) +[](https://lgtm.com/projects/g/nolar/kopf/alerts/) +[](https://lgtm.com/projects/g/nolar/kopf/context:python) +[](https://github.com/pre-commit/pre-commit) + +**Kopf** —Kubernetes Operator Pythonic Framework— is a framework and a library +to make Kubernetes operators development easier, just in a few lines of Python code. + +The main goal is to bring the Domain-Driven Design to the infrastructure level, +with Kubernetes being an orchestrator/database of the domain objects (custom resources), +and the operators containing the domain logic (with no or minimal infrastructure logic). + +The project was originally started as `zalando-incubator/kopf` in March 2019, +and then forked as `nolar/kopf` in August 2020: but it is the same codebase, +the same packages, the same developer(s). + + +## Documentation + +* https://kopf.readthedocs.io/ + + +## Features + +* Simple, but powerful: + * A full-featured operator in just 2 files: a `Dockerfile` + a Python file (*). + * Handling functions registered via decorators with a declarative approach. + * No infrastructure boilerplate code with K8s API communication. + * Both sync and async handlers, with sync ones being threaded under the hood. + * Detailed documentation with examples. +* Intuitive mapping of Python concepts to Kubernetes concepts and back: + * Marshalling of resources' data to the handlers' kwargs. + * Marshalling of handlers' results to the resources' statuses. + * Publishing of logging messages as Kubernetes events linked to the resources. +* Support anything that exists in K8s: + * Custom K8s resources. + * Builtin K8s resources (pods, namespaces, etc). + * Multiple resource types in one operator. + * Both cluster and namespaced operators. +* All the ways of handling that a developer can wish for: + * Low-level handlers for events received from K8s APIs "as is" (an equivalent of _informers_). + * High-level handlers for detected causes of changes (creation, updates with diffs, deletion). + * Handling of selected fields only instead of the whole objects (if needed). + * Dynamically generated or conditional sub-handlers (an advanced feature). + * Timers that tick as long as the resource exists, optionally with a delay since the last change. + * Daemons that run as long as the resource exists (in threads or asyncio-tasks). + * Validating and mutating admission webhook (with dev-mode tunneling). + * Live in-memory indexing of resources or their excerpts. + * Filtering with stealth mode (no logging): by arbitrary filtering functions, + by labels/annotations with values, presence/absence, or dynamic callbacks. + * In-memory all-purpose containers to store non-serializable objects for individual resources. +* Eventual consistency of handling: + * Retrying the handlers in case of arbitrary errors until they succeed. + * Special exceptions to request a special retry or to never retry again. + * Custom limits for the number of attempts or the time. + * Implicit persistence of the progress that survives the operator restarts. + * Tolerance to restarts and lengthy downtimes: handles the changes afterwards. +* Awareness of other Kopf-based operators: + * Configurable identities for different Kopf-based operators for the same resource kinds. + * Avoiding double-processing due to cross-pod awareness of the same operator ("peering"). + * Pausing of a deployed operator when a dev-mode operator runs outside of the cluster. +* Extra toolkits and integrations: + * Some limited support for object hierarchies with name/labels propagation. + * Friendly to any K8s client libraries (and is client agnostic). + * Startup/cleanup operator-level handlers. + * Liveness probing endpoints and rudimentary metrics exports. + * Basic testing toolkit for in-memory per-test operator running. + * Embeddable into other Python applications. +* Highly configurable (to some reasonable extent). + +(*) _Small font: two files of the operator itself, plus some amount of +deployment files like RBAC roles, bindings, service accounts, network policies +— everything needed to deploy an application in your specific infrastructure._ + + +## Examples + +See [examples](https://github.com/nolar/kopf/tree/main/examples) +for the examples of the typical use-cases. + +A minimalistic operator can look like this: + +```python +import kopf + +@kopf.on.create('kopfexamples') +def create_fn(spec, name, meta, status, **kwargs): + print(f"And here we are! Created {name} with spec: {spec}") +``` + +Numerous kwargs are available, such as `body`, `meta`, `spec`, `status`, +`name`, `namespace`, `retry`, `diff`, `old`, `new`, `logger`, etc: +see [Arguments](https://kopf.readthedocs.io/en/latest/kwargs/) + +To run a never-exiting function for every resource as long as it exists: + +```python +import time +import kopf + +@kopf.daemon('kopfexamples') +def my_daemon(spec, stopped, **kwargs): + while not stopped: + print(f"Object's spec: {spec}") + time.sleep(1) +``` + +Or the same with the timers: + +```python +import kopf + +@kopf.timer('kopfexamples', interval=1) +def my_timer(spec, **kwargs): + print(f"Object's spec: {spec}") +``` + +That easy! For more features, see the [documentation](https://kopf.readthedocs.io/). + + +## Usage + +Python 3.7+ is required: +[CPython](https://www.python.org/) and [PyPy](https://www.pypy.org/) +are officially supported and tested; other Python implementations can work too. + +We assume that when the operator is executed in the cluster, it must be packaged +into a docker image with a CI/CD tool of your preference. + +```dockerfile +FROM python:3.11 +ADD . /src +RUN pip install kopf +CMD kopf run /src/handlers.py --verbose +``` + +Where `handlers.py` is your Python script with the handlers +(see `examples/*/example.py` for the examples). + +See `kopf run --help` for other ways of attaching the handlers. + + +## Contributing + +Please read [CONTRIBUTING.md](https://github.com/nolar/kopf/blob/main/CONTRIBUTING.md) +for details on our process for submitting pull requests to us, and please ensure +you follow the [CODE_OF_CONDUCT.md](https://github.com/nolar/kopf/blob/main/CODE_OF_CONDUCT.md). + +To install the environment for the local development, +read [DEVELOPMENT.md](https://github.com/nolar/kopf/blob/main/DEVELOPMENT.md). + + +## Versioning + +We use [SemVer](http://semver.org/) for versioning. For the versions available, +see the [releases on this repository](https://github.com/nolar/kopf/releases). + + +## License + +This project is licensed under the MIT License — +see the [LICENSE](https://github.com/nolar/kopf/blob/main/LICENSE) file for details. + + +## Acknowledgments + +* Thanks to Zalando for starting this project in Zalando's Open-Source Incubator + in the first place. +* Thanks to [@side8](https://github.com/side8) and their [k8s-operator](https://github.com/side8/k8s-operator) + for inspiration. + + +%package help +Summary: Development documents and examples for kopf +Provides: python3-kopf-doc +%description help +# Kubernetes Operator Pythonic Framework (Kopf) + +[](https://pypi.org/project/kopf/) +[](https://github.com/nolar/kopf/actions/workflows/thorough.yaml) +[](https://codecov.io/gh/nolar/kopf) +[](https://coveralls.io/github/nolar/kopf?branch=main) +[](https://lgtm.com/projects/g/nolar/kopf/alerts/) +[](https://lgtm.com/projects/g/nolar/kopf/context:python) +[](https://github.com/pre-commit/pre-commit) + +**Kopf** —Kubernetes Operator Pythonic Framework— is a framework and a library +to make Kubernetes operators development easier, just in a few lines of Python code. + +The main goal is to bring the Domain-Driven Design to the infrastructure level, +with Kubernetes being an orchestrator/database of the domain objects (custom resources), +and the operators containing the domain logic (with no or minimal infrastructure logic). + +The project was originally started as `zalando-incubator/kopf` in March 2019, +and then forked as `nolar/kopf` in August 2020: but it is the same codebase, +the same packages, the same developer(s). + + +## Documentation + +* https://kopf.readthedocs.io/ + + +## Features + +* Simple, but powerful: + * A full-featured operator in just 2 files: a `Dockerfile` + a Python file (*). + * Handling functions registered via decorators with a declarative approach. + * No infrastructure boilerplate code with K8s API communication. + * Both sync and async handlers, with sync ones being threaded under the hood. + * Detailed documentation with examples. +* Intuitive mapping of Python concepts to Kubernetes concepts and back: + * Marshalling of resources' data to the handlers' kwargs. + * Marshalling of handlers' results to the resources' statuses. + * Publishing of logging messages as Kubernetes events linked to the resources. +* Support anything that exists in K8s: + * Custom K8s resources. + * Builtin K8s resources (pods, namespaces, etc). + * Multiple resource types in one operator. + * Both cluster and namespaced operators. +* All the ways of handling that a developer can wish for: + * Low-level handlers for events received from K8s APIs "as is" (an equivalent of _informers_). + * High-level handlers for detected causes of changes (creation, updates with diffs, deletion). + * Handling of selected fields only instead of the whole objects (if needed). + * Dynamically generated or conditional sub-handlers (an advanced feature). + * Timers that tick as long as the resource exists, optionally with a delay since the last change. + * Daemons that run as long as the resource exists (in threads or asyncio-tasks). + * Validating and mutating admission webhook (with dev-mode tunneling). + * Live in-memory indexing of resources or their excerpts. + * Filtering with stealth mode (no logging): by arbitrary filtering functions, + by labels/annotations with values, presence/absence, or dynamic callbacks. + * In-memory all-purpose containers to store non-serializable objects for individual resources. +* Eventual consistency of handling: + * Retrying the handlers in case of arbitrary errors until they succeed. + * Special exceptions to request a special retry or to never retry again. + * Custom limits for the number of attempts or the time. + * Implicit persistence of the progress that survives the operator restarts. + * Tolerance to restarts and lengthy downtimes: handles the changes afterwards. +* Awareness of other Kopf-based operators: + * Configurable identities for different Kopf-based operators for the same resource kinds. + * Avoiding double-processing due to cross-pod awareness of the same operator ("peering"). + * Pausing of a deployed operator when a dev-mode operator runs outside of the cluster. +* Extra toolkits and integrations: + * Some limited support for object hierarchies with name/labels propagation. + * Friendly to any K8s client libraries (and is client agnostic). + * Startup/cleanup operator-level handlers. + * Liveness probing endpoints and rudimentary metrics exports. + * Basic testing toolkit for in-memory per-test operator running. + * Embeddable into other Python applications. +* Highly configurable (to some reasonable extent). + +(*) _Small font: two files of the operator itself, plus some amount of +deployment files like RBAC roles, bindings, service accounts, network policies +— everything needed to deploy an application in your specific infrastructure._ + + +## Examples + +See [examples](https://github.com/nolar/kopf/tree/main/examples) +for the examples of the typical use-cases. + +A minimalistic operator can look like this: + +```python +import kopf + +@kopf.on.create('kopfexamples') +def create_fn(spec, name, meta, status, **kwargs): + print(f"And here we are! Created {name} with spec: {spec}") +``` + +Numerous kwargs are available, such as `body`, `meta`, `spec`, `status`, +`name`, `namespace`, `retry`, `diff`, `old`, `new`, `logger`, etc: +see [Arguments](https://kopf.readthedocs.io/en/latest/kwargs/) + +To run a never-exiting function for every resource as long as it exists: + +```python +import time +import kopf + +@kopf.daemon('kopfexamples') +def my_daemon(spec, stopped, **kwargs): + while not stopped: + print(f"Object's spec: {spec}") + time.sleep(1) +``` + +Or the same with the timers: + +```python +import kopf + +@kopf.timer('kopfexamples', interval=1) +def my_timer(spec, **kwargs): + print(f"Object's spec: {spec}") +``` + +That easy! For more features, see the [documentation](https://kopf.readthedocs.io/). + + +## Usage + +Python 3.7+ is required: +[CPython](https://www.python.org/) and [PyPy](https://www.pypy.org/) +are officially supported and tested; other Python implementations can work too. + +We assume that when the operator is executed in the cluster, it must be packaged +into a docker image with a CI/CD tool of your preference. + +```dockerfile +FROM python:3.11 +ADD . /src +RUN pip install kopf +CMD kopf run /src/handlers.py --verbose +``` + +Where `handlers.py` is your Python script with the handlers +(see `examples/*/example.py` for the examples). + +See `kopf run --help` for other ways of attaching the handlers. + + +## Contributing + +Please read [CONTRIBUTING.md](https://github.com/nolar/kopf/blob/main/CONTRIBUTING.md) +for details on our process for submitting pull requests to us, and please ensure +you follow the [CODE_OF_CONDUCT.md](https://github.com/nolar/kopf/blob/main/CODE_OF_CONDUCT.md). + +To install the environment for the local development, +read [DEVELOPMENT.md](https://github.com/nolar/kopf/blob/main/DEVELOPMENT.md). + + +## Versioning + +We use [SemVer](http://semver.org/) for versioning. For the versions available, +see the [releases on this repository](https://github.com/nolar/kopf/releases). + + +## License + +This project is licensed under the MIT License — +see the [LICENSE](https://github.com/nolar/kopf/blob/main/LICENSE) file for details. + + +## Acknowledgments + +* Thanks to Zalando for starting this project in Zalando's Open-Source Incubator + in the first place. +* Thanks to [@side8](https://github.com/side8) and their [k8s-operator](https://github.com/side8/k8s-operator) + for inspiration. + + +%prep +%autosetup -n kopf-1.36.0 + +%build +%py3_build + +%install +%py3_install +install -d -m755 %{buildroot}/%{_pkgdocdir} +if [ -d doc ]; then cp -arf doc %{buildroot}/%{_pkgdocdir}; fi +if [ -d docs ]; then cp -arf docs %{buildroot}/%{_pkgdocdir}; fi +if [ -d example ]; then cp -arf example %{buildroot}/%{_pkgdocdir}; fi +if [ -d examples ]; then cp -arf examples %{buildroot}/%{_pkgdocdir}; fi +pushd %{buildroot} +if [ -d usr/lib ]; then + find usr/lib -type f -printf "/%h/%f\n" >> filelist.lst +fi +if [ -d usr/lib64 ]; then + find usr/lib64 -type f -printf "/%h/%f\n" >> filelist.lst +fi +if [ -d usr/bin ]; then + find usr/bin -type f -printf "/%h/%f\n" >> filelist.lst +fi +if [ -d usr/sbin ]; then + find usr/sbin -type f -printf "/%h/%f\n" >> filelist.lst +fi +touch doclist.lst +if [ -d usr/share/man ]; then + find usr/share/man -type f -printf "/%h/%f.gz\n" >> doclist.lst +fi +popd +mv %{buildroot}/filelist.lst . +mv %{buildroot}/doclist.lst . + +%files -n python3-kopf -f filelist.lst +%dir %{python3_sitelib}/* + +%files help -f doclist.lst +%{_docdir}/* + +%changelog +* Mon Apr 10 2023 Python_Bot <Python_Bot@openeuler.org> - 1.36.0-1 +- Package Spec generated |