---
title: Kubevirt Pvc
slug: homologacao-atmosphere/kubevirt-pvc
description: Learn how to manage PVCs in Kubernetes using the OpenShift Python SDK with this comprehensive document. Discover the requirements for the host system, explore parameter details, and understand authentication and data source options in the API. Find out ab
docTags: 
createdAt: 2021-09-20T10:38:59.000Z
---

## Resumo

- Use o OpenShift Python SDK para gerenciar PVCs no Kubernetes
- Suporte ao importador de dados em contêineres pronto para uso

## Requisitos

Os requisitos abaixo são necessários no host que executa este módulo.

- python> = 2,7
- openshift> = 0.8.2

## Parâmetros

| **Parâmetro**                                               | **Tipo**               | **Escolhas \| Valor Padrão**                              | **Comentários**                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            |
| ----------------------------------------------------------- | ---------------------- | --------------------------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| access\_modes                                               | list / elements=string |                                                           | Contém os modos de acesso desejados que o volume deve ter.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 |
| annotations                                                 | dictionary             |                                                           | Anotações anexadas a este objeto.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          |
| api\_key                                                    | string                 |                                                           | Token usado para autenticação com a API. Também pode ser especificado por meio da variável de ambiente K8S\_AUTH\_API\_KEY.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                |
| ca\_cert                                                    | path                   |                                                           | Caminho para um certificado CA usado para autenticação com a API. A cadeia de certificação completa deve ser fornecida para evitar erros de validação de certificado. <br /><br />Também pode ser especificado por meio da variável de ambiente K8S\_AUTH\_SSL\_CA\_CERT.<br />                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            |
| cdi\_source                                                 | dictionary             |                                                           | Se os dados devem ser copiados no PVC usando o Importador de dados em contêiner, você pode especificar a fonte dos dados (junto com qualquer configuração adicional), bem como seu formato.<br /><br />Os tipos de fonte válidos são: blank, http, s3, registry, pvc e upload. O último requer o uso do módulo community.kubevirt.kubevirt\_cdi\_upload para realmente realizar um upload.<br /><br />O formato dos dados de origem é especificado usando `content_type` opcional . As opções válidas são kubevirt(default; raw image) e `archive`(tar.gz).                                                                                                                                                                                                                                                |
| client\_cert<br /><br />aliases: cert\_file                 | path                   |                                                           | Caminho para um certificado usado para autenticação com a API. Também pode ser especificado por meio da variável de ambiente K8S\_AUTH\_CERT\_FILE.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        |
| client\_key<br /><br />aliases: key\_file                   | path                   |                                                           | Caminho para um arquivo de chave usado para autenticação com a API. Também pode ser especificado por meio da variável de ambiente K8S\_AUTH\_KEY\_FILE.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    |
| context                                                     | string                 |                                                           | O nome de um contexto encontrado no arquivo de configuração. Também pode ser especificado por meio da variável de ambiente K8S\_AUTH\_CONTEXT.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             |
| force                                                       | boolean                | Escolhas:<br />- false<br />(default)<br />- true         | Se definido como `True` e o state for `present`, um objeto existente será substituído.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     |
| host                                                        | string                 |                                                           | Forneça um URL para acessar a API. Também pode ser especificado por meio da variável de ambiente K8S\_AUTH\_HOST.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          |
| kubeconfig                                                  | path                   |                                                           | Caminho para um arquivo de configuração Kubernetes existente. Se não for fornecido e nenhuma outra opção de conexão for fornecida, o cliente openshift tentará carregar o arquivo de configuração padrão de *\~/.kube/config.json* . Também pode ser especificado por meio da variável de ambiente K8S\_AUTH\_KUBECONFIG.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  |
| labels                                                      | dictionary             |                                                           | Etiquetas anexadas a este objeto.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          |
| merge\_type                                                 | list / elements=string | Escolhas:<br />- json<br />- merge<br />- strategic-merge | Se a abordagem de mesclagem de patch padrão deve ser substituída por um tipo específico.<br /><br />O padrão é \['`strategic-merge`', '`merge`'], que é ideal para usar os mesmos parâmetros em tipos de recursos que combinam recursos personalizados e recursos internos.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                |
| name - required                                             | string                 |                                                           | Use para especificar um nome de objeto PVC.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                |
| namespace - required                                        | string                 |                                                           | Use para especificar um namespace de objeto PVC.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           |
| password                                                    | string                 |                                                           | Forneça uma senha para autenticação com a API. Também pode ser especificado por meio da variável de ambiente K8S\_AUTH\_PASSWORD.<br /><br />Leia a descrição da opção `username` para uma discussão sobre quando esta opção é aplicável.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  |
| persist\_config                                             | boolean                | Escolhas:<br />- false<br />(default)<br />- true         | Se deve ou não salvar os tokens de atualização de configuração do kube. Também pode ser especificado por meio da variável de ambiente K8S\_AUTH\_PERSIST\_CONFIG.<br /><br />Quando o contexto k8s está usando credenciais de usuário com tokens de atualização (como oidc ou gke / gcloud auth), o token é atualizado pela biblioteca cliente python k8s, mas não é salvo por padrão. Portanto, o token de atualização antigo pode expirar e a próxima autenticação pode falhar. Definir este sinalizador como verdadeiro dirá ao cliente python k8s para salvar o novo token de atualização no arquivo de configuração do kube.<br /><br />Padrão para falso.<br /><br />Observe que a versão atual da biblioteca cliente python k8s ainda não suporta a configuração deste sinalizador como Verdadeiro. |
| proxy                                                       | string                 |                                                           | A URL de um proxy HTTP a ser usado para a conexão. Também pode ser especificado por meio da variável de ambiente K8S\_AUTH\_PROXY.<br /><br />Observe que este módulo não coleta configurações de proxy típicas do ambiente (por exemplo, HTTP\_PROXY).                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    |
| resource\_definition<br /><br />aliases: definition, inline | dictionary             |                                                           | Uma definição parcial YAML do objeto PVC sendo criado / atualizado. Aqui você pode definir os parâmetros do recurso de PVC do Kubernetes não cobertos pelos parâmetros deste módulo.<br /><br />NOTA: `resource_definition` tem prioridade mais baixa do que os parâmetros do módulo. Se você tentar definir, por exemplo, *metadata.namespace* aqui, esse valor será ignorado e o *namespace* usado em seu lugar.                                                                                                                                                                                                                                                                                                                                                                                         |
| selector                                                    | dictionary             |                                                           | Uma consulta de rótulo sobre os volumes a serem considerados para vinculação.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              |
| size<br /><br />aliases: storage                            | string                 |                                                           | Quanto armazenamento deve ser alocado para o PVC.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          |
| state                                                       | string                 | Escolhas:<br />- present<br />(default)<br />- absent     | Determina se um objeto deve ser criado, corrigido ou excluído. Quando definido como `present`, um objeto será criado, se ainda não existir. Se definido como `absent`, um objeto existente será excluído. Se definido como present, um objeto existente será corrigido, se seus atributos forem diferentes daqueles especificados usando as opções do módulo e *resource\_definition* .                                                                                                                                                                                                                                                                                                                                                                                                                    |
| storage\_class\_name                                        | string                 |                                                           | Nome do StorageClass exigido pela declaração.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              |
| username                                                    | string                 |                                                           | Forneça um nome de usuário para autenticação com a API. Também pode ser especificado por meio da variável de ambiente K8S\_AUTH\_USERNAME. Observe que isso só funciona com clusters configurados para usar HTTP Basic Auth. Se o seu cluster tiver uma forma diferente de autenticação (por exemplo, OAuth2 no OpenShift), esta opção não funcionará como esperado e você deve olhar para o módulo k8s\_auth, pois ele pode fazer o que você precisa.                                                                                                                                                                                                                                                                                                                                                     |
| validate\_certs<br /><br />aliases: verify\_ssl             | boolean                | Escolhas:<br />- fasle<br />(default)<br />- true         | Se deve ou não verificar os certificados SSL do servidor API. Também pode ser especificado por meio da variável de ambiente K8S\_AUTH\_VERIFY\_SSL.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        |
| volume\_mode                                                | string                 |                                                           | Isso define o tipo de volume exigido pelo sinistro. O valor do sistema de arquivos está implícito quando não incluído na especificação da reivindicação. Este é um recurso alfa do kubernetes e pode mudar no futuro.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
| volume\_name                                                | string                 |                                                           | Esta é a referência vinculativa ao PersistentVolume que apóia esta afirmação.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              |
| wait                                                        | boolean                | Escolhas:<br />- false<br />(default)<br />- true         | Se configurado, este módulo aguardará até que o PVC seja vinculado e o CDI (se habilitado) conclua sua operação antes de retornar.<br /><br />Usado apenas se o state estiver definido como `present`.<br /><br />A menos que usado em conjunto com *cdi\_source* , isso pode resultar em um tempo limite, pois os clusters podem ser configurados para não vincular PVCs até o primeiro uso.                                                                                                                                                                                                                                                                                                                                                                                                              |
| wait\_timeout                                               | integer                | Default:<br />300                                         | Especifica quanto tempo em segundos deve-se esperar pela conclusão da criação do PVC se a opção de *espera* estiver habilitada.<br /><br />O valor padrão é razoavelmente alto devido à expectativa de que o CDI demore um pouco para finalizar sua operação.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              |

Extende fragmentos da documentação dos módulos [Kubervirt Auth Options](https://app.archbee.io/docs/qhqZWWA92JYWAihQOL_T5/PrWSAs5NinklxurgCUKz1)


## Notas

Observação

- O cliente OpenShift Python envolve o cliente Python K8s, fornecendo acesso total a todos os APIS e modelos disponíveis em ambas as plataformas. Para obter detalhes da versão da API e informações adicionais, visite [https://github.com/openshift/openshift-restclient-python](https://github.com/openshift/openshift-restclient-python)
- Para evitar erros de validação de certificado SSL quando validate\_certsfor *True* , toda a cadeia de certificados para o servidor API deve ser fornecida via ca\_certou no arquivo kubeconfig.

## [Exemplos](https://docs.ansible.com/ansible/latest/collections/community/kubevirt/kubevirt_pvc_module.html#id5)[](https://docs.ansible.com/ansible/latest/collections/community/kubevirt/kubevirt_pvc_module.html#examples)

```yaml
- name: Crie um PVC e importe dados de uma fonte externa
  kubevirt_pvc:
    name: pvc1
    namespace: default
    size: 100Mi
    access_modes:
      - ReadWriteOnce
    cdi_source:
      http:
        url: https://www.source.example/path/of/data/vm.img
      # Se o URL apontar para um tar.gz contendo a imagem do disco, descomente a linha abaixo:
      #content_type: archive

- name: Crie um PVC como um clone de um PVC diferente
  kubevirt_pvc:
    name: pvc2
    namespace: default
    size: 100Mi
    access_modes:
      - ReadWriteOnce
    cdi_source:
      pvc:
        namespace: source-ns
        name: source-pvc

- name: Crie um PVC pronto para upload de dados
  kubevirt_pvc:
    name: pvc3
    namespace: default
    size: 100Mi
    access_modes:
      - ReadWriteOnce
    cdi_source:
      upload: yes
    # Você precisa do módulo kubevirt_cdi_upload para realmente fazer o upload de algo

- name: Crie um PVC com uma imagem bruta em branco
  kubevirt_pvc:
    name: pvc4
    namespace: default
    size: 100Mi
    access_modes:
      - ReadWriteOnce
    cdi_source:
      blank: yes

- name: Crie um PVC e preencha-o com dados de um contêiner
  kubevirt_pvc:
    name: pvc5
    namespace: default
    size: 100Mi
    access_modes:
      - ReadWriteOnce
    cdi_source:
      registry:
        url: "docker://kubevirt/fedora-cloud-registry-disk-demo"

```

## Valores Retornados[](https://docs.ansible.com/ansible/latest/collections/community/kubevirt/kubevirt_pvc_module.html#return-values)

| **Chave** | **Tipo** | **Retornado quando** | **Descrição**                                                                                  |
| --------- | -------- | -------------------- | ---------------------------------------------------------------------------------------------- |
| result    | complex  | sucesso              | O objeto criado, corrigido ou presente de outra forma. Estará vazio no caso de exclusão.<br /> |

### Subcampos da chave de retorno result

| **Chave**    | **Tipo**               | **Retornado quando**                                              | **Descrição**                                                                                  |
| ------------ | ---------------------- | ----------------------------------------------------------------- | ---------------------------------------------------------------------------------------------- |
| api\_version | string                 | sucesso                                                           | O esquema com versão desta representação de um objeto.                                         |
| duration     | integer                | Quando `wait` é true                                              | tempo decorrido da tarefa em segundos                                                          |
| items        | list / elements=string | quando `resource_definition` ou `src` contém uma lista de objetos | Retornado apenas quando vários documentos yaml são passados ​​para src ou resource\_definition |
| kind         | string                 | sucesso                                                           | Representa o recurso REST que este objeto representa.                                          |
| metadata     | complex                | sucesso                                                           | Metadados de objeto padrão. Inclui nome, namespace, anotações, rótulos, etc.                   |
| spec         | complex                | sucesso                                                           | Atributos específicos do objeto. Irá variar com base na *api\_version* e no *tipo* .           |
| status       | complex                | sucesso                                                           | Detalhes do status atual do objeto.                                                            |





