---
title: Kubevirt Cdi Upload
slug: homologacao-atmosphere/kubevirt-cdi-upload
description: Learn how to use the OpenShift Python SDK to effortlessly create UploadTokenRequest objects and seamlessly transfer local file content to the CDI Upload Proxy. This comprehensive document outlines the necessary host requirements and thoroughly explains th
docTags: 
createdAt: 2021-09-17T11:34:42.000Z
---

## Resumo

- Use o OpenShift Python SDK para criar objetos UploadTokenRequest.
- Transfira o conteúdo dos arquivos locais para o CDI Upload Proxy.

## Requisitos

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

- python> = 2,7
- openshift> = 0.8.2
- solicitações> = 2.0.0

## Parâmetros

| **Parâmetro**                                                               | **Tipo**               | **Escolhas \| Valor Padrão**                              | **Comentários**                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        |
| --------------------------------------------------------------------------- | ---------------------- | --------------------------------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| 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<br /><br />aliases: ssl\_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. Também pode ser especificado por meio da variável de ambiente K8S\_AUTH\_SSL\_CA\_CERT.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          |
| 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.<br />                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          |
| 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.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         |
| 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.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               |
| 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. Por padrão, a fusão estratégica normalmente será usada.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       |
| 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. Leia a descrição da opção `username` para uma discussão sobre quando esta opção é aplicável.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         |
| path                                                                        | string                 |                                                           | Caminho do arquivo de imagem local a ser transferido.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  |
| persist\_config                                                             | boolean                | Escolhas:<br />- true<br />- false                        | 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.<br /><br />A correção para esta biblioteca python k8s está aqui: https\://github.com/kubernetes-client/python-base/pull/169 |
| 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).                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                |
| pvc\_name - required                                                        | string                 |                                                           | Use para especificar o nome do PersistentVolumeClaim de destino.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       |
| pvc\_namespace - required                                                   | string                 |                                                           | Use para especificar o namespace do PersistentVolumeClaim de destino.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  |
| upload\_host                                                                | string                 |                                                           | URL que contém o host e a porta em que o proxy de upload do CDI está disponível.Mais informações:[https://github.com/kubevirt/containerized-data-importer/blob/master/doc/upload.md#expose-cdi-uploadproxy-service](https://github.com/kubevirt/containerized-data-importer/blob/master/doc/upload.md#expose-cdi-uploadproxy-service)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  |
| upload\_host\_validate\_certs<br /><br />aliases: upload\_host\_verify\_ssl | boolean                | Escolhas:<br />- true(default)<br />- false               | Se deve ou não verificar os certificados SSL do CDI Upload Proxy em relação ao armazenamento confiável da CA do seu sistema.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           |
| 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.<br /><br />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á conforme o esperado e você deve olhar para o k8s\_authmódulo, pois ele pode fazer o que você precisa.                                                                                                                                                                                                                                                                                                                                                                                                                                                                 |
| validate\_certs<br /><br />aliases: verify\_ssl                             | boolean                | Escolhas:<br />- true<br />- false                        | 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.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    |


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

## Notas

- 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.

## Exemplo

```yaml
- name: Faça upload da imagem local para pvc-vm1
  kubevirt_cdi_upload:
    pvc_namespace: default
    pvc_name: pvc-vm1
    upload_host: https://localhost:8443
    upload_host_validate_certs: false
    path: /tmp/cirros-0.4.0-x86_64-disk.img
```




