update-version-0.34.0 (#2351)

[create-pull-request] automated change
Add missing 0.34.0 release notes and move misplaced notes out of 0.33.0

New notes for PRs that were missing reno files:

2338: informative auth error messages (surface server reason to caller)
2300: hide cross-author job result on provider job listing
2345: surface non-JSON error responses (fix JSON1001 mislead)

Move notes that were accidentally placed in 0.33.0/ after that release:

ray-optional-client (#2332)
bump-qiskit-2.2-drop-symengine (#2333)
fix-eu-de-region-auth (#2325)

Move fix-eu-de-region-auth note back to 0.33.0
Move 0.34.0 release notes into 0.34.0/ subfolder
Fix release note categories and reword provider job listing note

cotengrust and ray-optional: features -> upgrade (dependency changes)
ray-optional: drop redundant features blurb, keep upgrade section only
hide-cross-author-job-result: move from security to upgrade, reword to describe the behaviour neutrally rather than framing it as a fix

Polish 0.34.0 release notes

cotengrust: reword from feature-voice to upgrade-voice
remove-client-widget: fix whitespace, drop vague closing sentence
fix-job-status-sub-status: remove internal PR reference
bump-qiskit-2.2: collapse three bullets into one user-facing note, drop internal build details (gateway qpy-compat, image symengine copy)

Add prelude for 0.34.0 release notes

Co-authored-by: riley2012 17478867+riley2012@users.noreply.github.com Co-authored-by: ElePT epenatap@gmail.com

Qiskit Serverless

Qiskit Serverless is a user-friendly tool that enables you to easily run complex quantum computing tasks. With this software, you can execute Qiskit Functions as long running jobs and distribute them across multiple CPUs, GPUs, and QPUs. This means you can take on more complex quantum-classical programs and run them with ease. You don’t have to worry about configuration or scaling up computational resources, as Qiskit Serverless takes care of everything for you.

diagram

Quickstart
1. Using Docker
2. Using Kubernetes
Modules
1. Client
2. Gateway
3. Charts
How to Give Feedback
Contribution Guidelines
Deprecation Policy
References and Acknowledgements
License

Quickstart

This Quickstart section guides users to easily deploy Qiskit Serverless infrastructure and run a simple example.

Docker

For user convenience, this section assumes that users will deploy the infrastructure in a local environment using Docker following the next steps.

Prepare local Qiskit Serverless infrastructure

Install Docker You can use any runtime that you prefer to run Docker on your machine: Docker Desktop, podman… If you are using a MacOS with ARM processors we highly recommend to use Colima as your container runtime to avoid problems with that architecture.

This is a project that takes advantage of distributed computing, so it places a high demand on resources. We recommend increasing the assigned resources to these runtimes. In case of Colima for example we typically use:
```
colima start --cpu 4 --memory 8 --disk 100
```
Install qiskit-serverless on your local system (we recommend using a virtual environment).
```
pip install qiskit-serverless
```

Clone the Qiskit Serverless repository

git clone https://github.com/Qiskit/qiskit-serverless.git

Run Qiskit Serverless infrastructure Execute Docker Compose using the following commands.

cd qiskit-serverless/
sudo docker compose up

The output should resemble the following.

~/qiskit-serverless$ sudo docker compose --profile jupyter up
[+] Running 5/0
 ✔ Network public-qiskit-serverless_safe-tier     Created                                           0.0s
 ✔ Container ray-head                              Created                                           0.0s
 ✔ Container public-qiskit-serverless-postgres-1  Created                                           0.0s
 ✔ Container gateway                               Created                                           0.0s
 ✔ Container scheduler                             Created                                           0.0s
Attaching to gateway, public-qiskit-serverless-postgres-1, ray-head, scheduler

Write your first Qiskit Function following our hello-world example in the tutorial section.

That’s all!

Kubernetes

For user convenience, this section assumes that users will deploy the infrastructure in a local environment using Kind following the next steps.

Prepare local Qiskit Serverless infrastructure
1. Install Docker You can use any runtime that you prefer to run Docker on your machine: Docker Desktop, podman… If you are using a MacOS with ARM processors we highly recommend to use Colima as your container runtime to avoid problems with that architecture.
  
  This is a project that takes advantage of distributed computing, so it places a high demand on resources. We recommend increasing the assigned resources to these runtimes. In case of Colima for example we typically use:
```
colima start --cpu 4 --memory 8 --disk 100
```
2. Install Kind To simplify the process to deploy a k8s cluster locally we use Kind as the main tool to create a cluster.
3. Install qiskit-serverless on your local system (we recommend using a virtual environment).
```
pip install qiskit-serverless
```
4. Clone the Qiskit Serverless repository
```
git clone https://github.com/Qiskit/qiskit-serverless.git
```
5. Run Qiskit Serverless infrastructure Execute the script to setup the cluster
```
tox -e cluster-deploy
```
  The creation process can take some minutes.
Write your first Qiskit Function following our hello-world example in the tutorial section.

That’s all!

For more detailed examples and explanations refer to the Guide:

How to Give Feedback

We encourage your feedback! You can share your thoughts with us by:

Opening an issue in the repository

Contribution Guidelines

For information on how to contribute to this project, please take a look at our contribution guidelines.

Deprecation Policy

This project is meant to evolve rapidly and, as such, do not follow Qiskit’s deprecation policy. We may occasionally make breaking changes in order to improve the user experience. When possible, we will keep old interfaces and mark them as deprecated, as long as they can co-exist with the new ones. Each substantial improvement, breaking change, or deprecation will be documented in release notes.