qserv | LSST Query Services | Database library

As asked in the question:

Is there a simple way to extract PVC/PV yaml file so that I can re-create all PVs/PVCs using the same Google Disks.

Some scripting would be needed to extract a manifest that could be used without any hassles.

I found a StackOverflow thread about similar question (how to export manifests):

• Stackoverflow.com: Questions: Kubectl export is deprecated any alternative

A side note!

I also stumbled upon kubectl neat (a plugin for kubectl) which will be referenced later in that answer.

As correctly pointed by the author of the post, kubectl neat will show the message at the time of installation:

WARNING: You installed plugin "neat" from the krew-index plugin repository.

These plugins are not audited for security by the Krew maintainers. Run them at your own risk.

I would consider going with some backup solution as more a viable option due to the fact of data persistence and in general data protection in case of any failure.

From backup solution side you can look here:

• Portwortx.com: How to migrate stateful application from one gcp region to another with portwortx kubemotion
• Velero.io

PV's in GKE are in fact Google Persistent Disks. You can create a snapshot/image of a disk as a backup measure. You can also use this feature to test how your migration behaves:

• Cloud.google.com: Compute: Docs: Disks: Create snapshots
• Cloud.google.com: Compute: Docs: Images: Create delete deprecate private images

Please consider below example as a workaround.

I've managed to migrate an example Statefulset from one cluster to another with data stored on gce-pd.

Once more, I encourage you to check this docs about using preexisting disks in GKE to create a Statefulset:

• Cloud.google.com: Kubernetes Engine: Docs: How to: Persistent Volumes: Preexisting PD

Assuming that you used manifest from official Kubernetes site:

• Kubernetes.io: Docs: Concepts: Workloads: Controllers: Statefulset

You can migrate it to another cluster by:

• Setting the ReclaimPolicy to Retain on each PV used. <-- IMPORTANT
• Using kubectl neat to extract needed manifests
• Editing previously extracted manifests
• Deleting the existing workload on old cluster
• Creating a workload on new cluster

You will need to check if your PV ReclaimPolicy is set to Retain. This would stop gce-pd deletion after PVC and PV are deleted from the cluster. You can do it by following Kubernetes documentation:

• Kubernetes.io: Docs: Tasks: Administer cluster: Change PV reclaim policy

More reference:

• Cloud.google.com: Kubernetes Engine: Docs: Concepts: Persistent Volumes: Dynamic provisioning

There are many ways to extract the manifest from Kubernetes API. I stumbled upon kubectl neat here. kubectl-neat will remove some of the fields in the manifests.

I used it in a following manner:

• $ kubectl get statefulset -o yaml | kubectl neat > final-sts.yaml
• $ kubectl get pvc -o yaml | kubectl neat > final-pvc.yaml
• $ kubectl get pv -o yaml | kubectl neat > final-pv.yaml

Disclaimer!

This workaround will use the names of the dynamically created disks in GCP. If you were to create new disks (from snapshot for example) you would need to modify whole setup (use preexsiting disks guide referenced earlier).

Above commands would store manifests of a StatefulSet used in the Kubernetes examples.

You will need to edit this manifests to be used in newly created cluster. This part could be automated:

• final-pv.yaml - delete the .claimRef in .spec

You will need to release used disks so that the new cluster could use them. You will need to delete this Statefulset and accompanying PVC's and PV's. Please make sure that the PV's reclaimPolicy is set to Retain.

You will need to use previously created manifest and apply them on a new cluster:

• $ kubectl apply -f final-pv.yaml
• $ kubectl apply -f final-pvc.yaml
• $ kubectl apply -f final-sts.yaml

As for exporting manifests you could also look (if feasible) on Kubernetes client libraries:

• Kubernetes.io: Docs: Reference: Using API: Client libraries

When formatting an SQL statement by hand (which you really SHOULD NOT do when input parameters are involved!), it is not enough to merely wrap parameter values in quotes. You need to also escape reserved characters inside of the parameter data, otherwise you are still susceptible to injection attacks. The attacker could simply place a matching quote inside the data, closing off your opening quote, and then the rest of the parameter data can contain malicious instructions.

For example:

The problem with this is that the event polling loop of the application will not run, so no events will be handled and your function calls will simply not work without it.

In short, the waitForConnected() call will wait for an event that never happens.

The natural solution with Qt is of course to use signals and slots, and let the normal application event loop run.

On a slightly related note: If you want internal communication within the same process consider something other than (heavy and complex) TCP sockets. Simple message queues? Anonymous pipes? Plain strings or arrays?

I followed the instructions mentioned by Elixir forum user

I am generally not a fan of the "let's do things to undo it later". It generally forces developers to keep a stack in their head of how things are added and removed later on.

In this case in particular, you are coupling on the test name. Imagine someone decides to make the "two" in "One, two, All" uppercase. Now all of the future overrides won't apply and you will have duplicate tests.

A better solution to explicit opt in what you need. For example, you can define smaller macros that you use when necessary:

In the configuration you specified token_types: ["refresh_token"].

By calling Guardian.encode you create access token that's why nothing is persisted in database.

To persist all types of tokens remove this line.