Artigo original: OpenStack Tutorial – Operate Your Own Private Cloud (Full Course)
O OpenStack é um software de código aberto que fornece infraestrutura em nuvem para máquinas virtuais, bare metal e contêineres.
Neste artigo, você aprenderá como usar o OpenStack para operar sua própria nuvem privada.
Ao final do tutorial, você terá uma compreensão básica do que é o OpenStack e conhecerá os conceitos básicos de configuração e administração do OpenStack usando a plataforma OpenMetal. Você também entenderá alguns serviços comumente usados do OpenStack.
Além de criar esta versão em forma de artigo do tutorial, também criei uma versão em vídeo. Você pode assistir ao vídeo no canal do freeCodeCamp.org no YouTube.
Para acompanhar este tutorial, pode ser útil ter uma compreensão básica da linha de comando, rede e virtualização do Linux. Nada disso, porém, é necessário.
Agradecemos à OpenMetal por patrocinar este tutorial.
O que é o OpenStack?
O OpenStack é uma plataforma de computação em nuvem de código aberto que é usada por organizações para gerenciar e controlar implementações em larga escala de máquinas virtuais, como em um ambiente de computação em nuvem ou servidor virtual privado. O OpenStack é uma escolha popular para organizações por ser escalável, confiável e fornecer um alto grau de controle sobre a infraestrutura subjacente.
Além de ser usado para gerenciar implementações de máquinas virtuais, o OpenStack também pode ser usado para gerenciar recursos de armazenamento e rede em um ambiente de nuvem.
De certa forma, o OpenStack pode ser comparado ao AWS, mas aqui estão algumas diferenças importantes entre os dois:
- O OpenStack é uma plataforma de código aberto, enquanto a AWS é uma plataforma proprietária.
- O OpenStack oferece mais flexibilidade e opções de personalização que a AWS.
- O OpenStack normalmente requer mais conhecimento técnico para configurar e gerenciar do que a AWS, pois você, basicamente, precisa configurar tudo sozinho.
Vamos entrar em mais detalhes sobre o que o OpenStack oferece.
Além da funcionalidade padrão de Infraestrutura como Serviço, componentes adicionais fornecem orquestração, gerenciamento de falhas e serviços e outros serviços para garantir a alta disponibilidade dos aplicativos do usuário.
O OpenStack é dividido em serviços para permitir que você conecte e reproduza componentes, dependendo de suas necessidades. O mapa do OpenStack abaixo mostra serviços comuns e como eles se encaixam.
Não vou abordar todos os serviços, mas aqui está o que alguns dos serviços mais comuns do OpenStack fazem.
Armazenamento de objeto: O OpenStack Object Storage (Swift) é um sistema de armazenamento distribuído de objetos altamente escalável.
Computação: o OpenStack Compute (Nova) é um controlador de serviço de computação em nuvem, que gerencia a alocação de recursos de compute, ou seja, de computação.
Rede: o OpenStack Networking (Neutron) é um sistema para gerenciar redes e endereços IP.
Painel: o OpenStack Dashboard (Horizon) é uma interface baseada na web para gerenciar recursos do OpenStack.
Identidade: o OpenStack Identity (Keystone) é um sistema para gerenciamento de contas de usuários e controle de acesso.
Imagem: o OpenStack Image (Glance) é um serviço para armazenar e recuperar imagens de máquinas virtuais.
Armazenamento em bloco: o OpenStack Block Storage (Cinder) é um serviço para gerenciar dispositivos de armazenamento em bloco.
Telemetria: o OpenStack Telemetry (Ceilometer) é um serviço para coletar e armazenar dados de medição.
Orquestração: o OpenStack Orchestration (Heat) é um serviço para orquestração e formação de nuvem.
Bare Metal: o OpenStack Bare Metal (Ironic) é um serviço para provisionamento e gerenciamento de servidores bare metal.
Processamento de dados: o OpenStack Data Processing (Sahara) é um serviço para provisionamento e gerenciamento de clusters Hadoop e Spark.
Demonstraremos alguns dos serviços mais comuns do OpenStack posteriormente neste curso.
Existem várias maneiras diferentes de implantar e configurar o OpenStack com base nas necessidades de seu aplicativo ou organização.
Neste curso, aprenderemos como começar a usar o OpenStack e muitos dos recursos mais comuns.
Uma das maneiras mais fáceis de começar a usar o OpenStack é usando a nuvem privada sob demanda do OpenMetal. Isso nos permite implantar rapidamente o OpenStack na nuvem e simplifica o processo de configuração. O OpenMetal forneceu uma concessão que tornou este tutorial possível.
Embora usemos o OpenMetal para aprender sobre o OpenStack, o material abordado neste tutorial se aplica a qualquer implantação do OpenStack, não apenas àquelas que usam o OpenMetal. Portanto, não importa como você queira usar o OpenStack, este tutorial é para você.
Configurando o OpenStack no OpenMetal
Para obter a configuração do OpenStack, você precisa provisionar e configurar sua nuvem no OpenMetal. Basta seguir as instruções na página do OpenMetal Central para configurar tudo.
As nuvens privadas na OpenMetal são implantadas com OpenStack em três servidores bare metal. Esses três servidores compõem o núcleo da nuvem privada (Private Cloud Core). Para o OpenStack, esses três servidores são considerados o plano de controle. As nuvens privadas são implantadas com o Ceph, fornecendo armazenamento compartilhado à nuvem. O Ceph é uma solução de armazenamento definido por software de código aberto.
Vamos ver os ativos de hardware que foram criados no OpenMetal. Se você acabou de criar uma nuvem, talvez já esteja na página de gerenciamento de nuvem. Caso contrário, clique em "manage" para gerenciar. Agora clique em "Assets" no menu do lado esquerdo para ter acesso aos ativos.
Esta página contém uma lista de ativos incluídos em sua implantação de nuvem privada. Isso inclui os nós do plano de controle de hardware (Hardware Control Plane Nodes) e os blocos de IPs dos endereços IP de inventário (Inventory) e do provedor (Provider).
A captura de tela acima é uma lista de ativos em uma nuvem privada de demonstração. Sua nuvem privada pode ter hardware diferente com base nas opções que você selecionou em sua implantação.
Neste exemplo, você notará três seções principais:
- 3 nós de plano de controle de Cloud Core, do tipo mb_small_v1
- Blocos de endereços IP do inventário
- Blocos de endereços IP do provedor
Com essas nuvens privadas, o OpenStack é implantado com três nós de plano de controle hiperconvergentes.
Você pode acessar esses nós do plano de controle (Control Plane Nodes) diretamente por meio do SSH como usuário root. Esse acesso é feito por meio das chaves SSH que você forneceu durante a implantação da nuvem privada. Use este comando para se conectar (você terá que alterar o nome da chave e o IP para corresponder às suas informações):
ssh -i ~/.ssh/nome_da_sua_chave root@173.231.217.21
Primeiros passos com OpenStack Horizon
Horizon é o nome do painel padrão do OpenStack, que fornece uma interface de usuário baseada na web para os serviços do OpenStack. Ele permite que um usuário gerencie a nuvem.
Para acessar o painel OpenStack da sua nova nuvem (chamado Horizon), você precisará obter a senha de administrador do Horizon. O nome de usuário é "admin".
Para começar, use o SSH para entrar em um dos servidores da nuvem (você pode usar qualquer endereço IP da página de ativos "Assets"). Por exemplo:
ssh -i ~/.ssh/nome_da_sua_chave root@173.231.217.21
Uma vez autenticado no servidor, execute este comando:
grep keystone_admin_password /etc/kolla/passwords.yml
A senha será mostrada na saída como neste exemplo:
keystone_admin_password: aB0cD1eF2gH3iJ4kL5mN6oP7qR8sT9uV
A seguir, inicie o Horizon. No OpenMetal, você pode clicar na aba "Horizon", no menu à esquerda.
Autentique-se usando "admin" e a senha que você acabou de obter.
Criar um projeto no OpenStack Horizon
No OpenStack, a nuvem é dividida pelo uso de projetos. Os projetos têm usuários associados a eles, que possuem diferentes níveis de acesso, definidos por funções. Um administrador define limites de recursos por projeto modificando cotas.
Agora, vamos aprender como criar um projeto e associar um usuário a ele. Aprenderemos, também, sobre como as cotas do projeto podem ser ajustadas. A interface do Horizon será semelhante, não importando onde você implantará o OpenStack. Isso não é específico do OpenMetal.
Há três abas no nível da raiz no menu esquerdo do Horizon: Project, Admin e Identity. Somente usuários com privilégios administrativos podem ver a aba de admin.
Para criar seu primeiro projeto, navegue até Identity -> Projects.
Vários projetos já existem, incluindo o projeto admin. Esses projetos são implantados por padrão e geralmente não devem ser modificados.
Clique no botão Create Project, próximo ao canto superior direito, para criar um novo projeto.
No campo Name, especifique um nome para o projeto. Este projeto de exemplo é chamado de Development. Você também pode adicionar membros do projeto e grupos de projetos, mas ainda não vamos abordá-los. Clique em Create Project para concluir a criação do primeiro projeto.
Uma vez criado, o projeto aparece na página de listagem de projetos.
Na página de listagem do projeto, você pode visualizar e ajustar as cotas deste projeto como usuário admin. As cotas são limites de recursos, como o número de instâncias.
Para visualizar as cotas deste projeto enquanto estiver na aba Identity -> Projects, localize no menu suspenso à direita a primeira opção, Manage Members. Nesse menu, clique em Modify Quotas para visualizar os valores de cota padrão.
Você verá um formulário com várias abas e verá as cotas do serviço de computação. As cotas também existem para os serviços Volume e Network.
Você pode querer ajustar os parâmetros neste formulário, dependendo de sua carga de trabalho. Definir um valor como -1 significa que a cota é ilimitada.
Como criar um usuário e associá-lo ao projeto
Agora que você tem um projeto, pode associar um usuário a ele. Já existe o usuário padrão admin, mas agora vamos ver como criar um outro usuário e fazer login com ele.
Primeiro, navegue como admin para Identity -> Users. Por padrão, existem vários usuários já listados. Esse é o comportamento esperado. Eles são criados durante a implantação na nuvem e geralmente não devem ser modificados.
Clique no botão Create User.
No formulário de criação de usuário, defina valores de nome do usuário, senha, projeto principal e função (respectivamente, User Name, Password, Primary Project e Role). O campo Email é opcional, mas é útil para redefinições de senha. Para Project, escolha o projeto que criamos anteriormente.
Para Role, há várias opções, dependendo do nível de acesso necessário. As funções padrão (role) do OpenStack são reader, member e admin. Outras funções podem ser encontradas na lista suspensa. Reader é o papel com menos privilégios na hierarquia. Para este exemplo, escolha member para a função.
Pressione Create User para criar o usuário.
Em seguida, saia do Horizon como admin e autentique-se novamente com seu novo usuário. Neste novo acesso, você está, por padrão, no projeto recém-criado. Você pode ver o projeto em que está atualmente no canto superior esquerdo e seu usuário pode ser visto no canto superior direito do Horizon.
Gerenciando e criando imagens
Agora, vamos aprender como fazer upload de uma imagem (não uma imagem gráfica, mas uma cópia de uma instalação do Linux) no OpenStack, bem como criar imagens de uma instância existente.
As imagens contêm um sistema operacional inicializável que é usado para criar instâncias. Dentro da sua nuvem no OpenMetal, existem várias imagens diferentes que estão prontamente disponíveis, incluindo CentOS, Debian, Fedora e Ubuntu. Além disso, você tem a opção de fazer upload de imagens de outras fontes ou criar suas imagens.
Aprenderemos como fazer upload de imagens para o Glance por meio do Horizon e como criar uma imagem a partir de um snapshot de instância. O Glance é uma ferramenta de gerenciamento de imagens que permite aos usuários descobrir, recuperar e registrar imagens de VM (máquina virtual) e imagens de contêiner. O Glance usa o Ceph para armazenar imagens em vez do sistema de arquivos local.
Para acessar imagens de dentro do seu painel do Horizon, navegue até a aba Projects. Na guia de projetos, selecione Compute e, em seguida, selecione Images. Esta aba contém uma lista de todas as suas imagens no OpenStack.
As imagens podem ser carregadas por meio do painel do Horizon clicando no botão Create Image. Ao criar uma imagem, você deve escolher o formato da imagem. Com nossa configuração, o formato recomendado para imagens é QCOW2 – QEMU emulator. QCOW2 é o formato mais comum para Linux KVM, expande-se dinamicamente e oferece suporte à cópia na gravação.
Para fazer upload de uma imagem no Horizon, primeiro você deve ter a imagem localmente em sua máquina. Neste exemplo, faremos upload de uma imagem do CirrOS. Você pode baixar uma imagem do CirrOS aqui.
Agora, clique no botão Create Image, próximo ao canto superior direito.
Para este exemplo, vamos usar os seguintes valores para os campos:
- Image Name: Nome da imagem
- Image Description: Descrição opcional da imagem
- File: O arquivo fonte em sua máquina
- Format: QCOW2 – QEMU Emulator
Preencha os detalhes conforme necessário e envie o formulário. Pode levar algum tempo para concluir o upload da imagem.
Criar uma instância no OpenStack Horizon
Com o OpenStack, instâncias ou máquinas virtuais desempenham um papel importante na carga de trabalho de uma nuvem. O OpenStack fornece uma maneira de criar e gerenciar instâncias com seu serviço de computação, chamado Nova.
O Nova é o projeto do OpenStack que fornece uma maneira de provisionar instâncias de computação (também conhecidas como servidores virtuais). O Nova oferece suporte para a criação de máquinas virtuais, servidores bare metal e tem suporte limitado para contêineres do sistema. O Nova é executado como um conjunto de daemons sobre servidores Linux existentes para fornecer esse serviço.
Agora, vamos aprender como criar uma instância, incluindo a configuração de uma rede privada e de um roteador, a criação de um grupo de segurança e como adicionar um par de chaves SSH.
Criar uma rede privada
Primeiro, vamos aprender como criar uma rede privada e um roteador. Mais tarde, vamos criar uma instância nesta rede privada. O roteador é criado para que a rede privada possa ser conectada à rede pública da sua nuvem, permitindo que você atribua um endereço IP flutuante a ela, tornando a instância acessível pela Internet.
Para criar uma rede privada, comece navegando até Project -> Network -> Networks. Em seguida, clique em Create Network.
Para este exemplo, vamos criar uma rede com os seguintes detalhes:
- Network Name: Defina um nome para a rede. Neste exemplo, ela é chamada de Private.
- Enable Admin State: Deixe isso marcado para habilitar a rede.
- Create Subnet: Deixe isso marcado para criar uma sub-rede.
- Availability Zone Hints: Deixe essa opção como o padrão.
Em seguida, prossiga para a aba Subnet deste formulário e use esses detalhes:
- Subnet Name: Defina um nome para a sub-rede. Neste exemplo, ela é chamada de private-subnet.
- Network Address: Selecione um intervalo de rede privada. Por exemplo:
192.168.0.1/24 - IP Version: Deixe isso como IPv4.
- Gateway IP: Isso é opcional. Se não estiver marcado, um IP do gateway é selecionado automaticamente.
- Disable Gateway: Deixe isso desmarcado.
Por enquanto, vamos manter os detalhes padrão na aba Subnet Details.
Clique em Create para criar a rede. Uma vez criada, ela aparecerá na lista de redes.
Criar um roteador
Em seguida, você precisa criar um roteador para fazer a ponte entre a rede privada e a rede pública. A rede pública é chamada External.
Para criar um roteador, comece navegando até Project -> Network -> Routers. Clique em Create Router.
Insira esses dados para este exemplo:
- Router Name: Defina um nome para o roteador aqui. Neste exemplo, o roteador é chamado de Router.
- Enable Admin State: Deixe isso marcado para habilitar o roteador.
- External Network: Escolha a rede External.
- Availability Zone Hints: Deixe essa opção como o padrão.
Uma vez concluído, crie o roteador pressionando Create Router.
Conecte o roteador à rede privada
Em seguida, conecte o roteador à rede privada anexando uma interface. A execução desta etapa permite a comunicação de rede entre as redes Private e External.
Para anexar uma interface ao roteador, primeiro navegue até a lista de roteadores e localize aquele criado anteriormente.
Clique no nome do roteador para acessar sua página de detalhes. Este é o local onde a interface é anexada. Existem três abas: Visão geral, Interfaces e Rotas estáticas (respectivamente, Overview, Interfaces e Static Routes). Para anexar uma interface, navegue até a aba Interfaces e carregue o formulário para anexar uma interface clicando em Add Interface próximo ao canto superior direito.
Na nova interface, escolha a sub-rede privada para Subnet. Se você não definir um endereço IP, será selecionado um automaticamente. Pressione Submit para conectar a rede Private a este roteador. A interface é, então, anexada e listada.
Você pode ver visualmente a topologia de rede para sua nuvem navegando para Project -> Network -> Network Topology.
O exemplo acima indica que a rede External está conectada à rede Private por meio do roteador chamado Router.
Grupos de segurança
Também conhecidos como security groups, eles permitem o controle do tráfego de rede a partir de e para as instâncias. Por exemplo, a porta 22 pode ser aberta para SSH para um único IP ou um intervalo de IPs.
Vamos ver como criar um grupo de segurança para acesso por SSH. Posteriormente, você aplicará o grupo de segurança que criamos para uma instância.
Para ver e gerenciar grupos de segurança, navegue até Project -> Network -> Security Groups.
Você deve observar um único grupo de segurança, chamado default. Esse grupo de segurança restringe todo o tráfego de rede de entrada (ingresso ou ingress, em inglês) e permite todo o tráfego de rede de saída (egresso ou egress, em inglês). Quando uma instância é criada, esse grupo de segurança é aplicado por padrão. Para permitir o tráfego de rede que sua instância requer, abra apenas as portas conforme necessário somente para os intervalos de IP necessários.
Para criar um grupo de segurança para SSH, clique em Create Security Group, próximo ao canto superior direito.
Nomeie o grupo SSH e clique em Create Security Group
Depois de criar o grupo de segurança de SSH, precisamos adicionar uma regra que permita o tráfego SSH. Permitiremos o tráfego SSH do primeiro nó de hardware nesta nuvem para esta instância.
Para adicionar uma regra, carregue o formulário navegando até Add Rule próximo ao canto superior direito.
Precisaremos obter o endereço IP do primeiro nó de hardware da sua nuvem. Você pode encontrar isso usando o OpenMetal Central, na página de ativos da sua nuvem.
No menu Add Rule, adicione as seguintes informações:
- Rule: Selecione SSH. Ao adicionar regras, você pode escolher uma entre as opções predefinidas. Neste caso, vamos escolher a regra SSH do primeiro menu suspenso.
- Description: Opcional. Forneça uma descrição para a regra.
- Remote: Selecione CIDR.
- CIDR: Especifique o endereço IP do seu primeiro nó de hardware.
Pressione Add para adicionar esta regra ao grupo de segurança.
Criar uma instância
Agora, temos quase tudo pronto para criar uma instância.
Vamos precisar de uma chave pública SSH. Uma chave pública SSH é necessária para acessar uma instância por SSH. Essa chave é injetada na instância quando criada. Uma chave SSH não pode ser adicionada a uma instância já em execução.
Criaremos uma instância que pode ser acessada por SSH de um dos nós de hardware da nuvem. Portanto, teremos que criar um par de chaves SSH em um dos nós de hardware. A parte pública desse par de chaves está associada à instância que criaremos em breve.
** Para saber como criar esse par de chaves, consulte o guia complementar: Create SSH Key Pair for an OpenStack Control Plane Node (em inglês).
Para criar uma instância, comece navegando até Project -> Compute -> Instances. Em seguida, clique no botão Launch Instance.
Na aba de detalhes, preencha os seguintes detalhes:
- Instance Name: Defina um nome para a instância. Esta instância de exemplo é chamada de Jumpstation.
- Description: Opcional. Defina uma descrição se isso se aplicar.
- Availability Zone: Deixe como o padrão, que é nova.
- Count: Controla o número de instâncias geradas. Crie apenas 1.
Em seguida, acesse a aba Source, na qual você pode especificar uma imagem de sistema operacional.
Preencha os seguintes detalhes:
- Select Boot Source: Neste exemplo, nós usamos Image como a fonte de inicialização.
- Create New Volume: Deixe isso marcado como Yes. Isso cria um novo volume Cinder para o qual a imagem de sistema operacional específica é copiada. Em última análise, o volume existe com o cluster Ceph, no pool de
vms. - Volume Size: Permita que o sistema determine isso para você.
- Delete Volume on Instance Delete: Deixe esta opção definida com No. Se marcado, quando a instância é excluída, o volume também é.
- Sob a seção Available, selecione o sistema operacional apropriado. Este exemplo usa
CentOS 8 Stream (el8-x86_64). Clicar na seta para cima vai movê-lo para a seção Allocated.
Isso conclui a configuração da fonte da instância. Em seguida, vá para a aba Flavor.
Os flavors são uma maneira de definir as VCPUs, RAM e espaço em disco usados por uma instância. Flavors pré-construídos estão disponíveis para você. Para esta etapa, selecione um tipo apropriado nas opções sob o título Available. Este exemplo usa a opção "m1.small". Clique na seta para cima para movê-la para a seção Allocated.
Em seguida, vá para a aba Networks.
Nesta seção, você especifica a rede à qual a instância está associada. Para este exemplo, selecione a rede Private criada anteriormente. Você também pode escolher a rede External, mas geralmente é recomendado o uso de um IP flutuante caso sua instância exija conectividade com a Internet.
Você só deve expor partes de sua rede conforme necessário. Isso reduz a superfície de ataque e melhora a segurança do aplicativo. Se uma rede privada não for criada e uma instância for criada em uma nuvem padrão, ela será associada à rede External. Isso significa que a instância consome um IP público e pode ser acessada pela Internet.
Em seguida, pule a aba Network Ports e vá para Security Groups.
É aqui que você seleciona grupos de segurança para a instância. Este exemplo usa o grupo de segurança SSH na seção Available. Clique na seta para cima para mover o grupo de segurança SSH para a seção Allocated.
Como etapa final, vá para a aba Key Pair.
Nesta seção, você especifica uma chave pública SSH para injetar na instância. Você pode carregar sua chave neste estágio usando este formulário usando o botão Import Key Pair. Você também pode criar um par de chaves nesta aba.
Criaremos um par de chaves do primeiro nó de hardware em nossa nuvem para que essa instância seja acessível por SSH a partir desse nó.
Para criar o par de chaves SSH a partir do primeiro nó de hardware, a primeira etapa é fazer login no primeiro nó de hardware. Você pode obter o IP do nó de hardware na aba Assets no OpenMetal. Já nos conectamos a este nó no início do tutorial e o comando é o mesmo. Vai parecer algo assim:
ssh -i ~/.ssh/nome_da_sua_chave root@173.231.217.21
Após se autenticar no nó, use ssh-keygen para gerar um par de chaves SSH.
Por exemplo:
[root@modest-galliform ~]# ssh-keygen
Generating public/private rsa key pair.
Enter file in which to save the key (/root/.ssh/id_rsa):
Enter passphrase (empty for no passphrase):
Enter same passphrase again:
Your identification has been saved in /root/.ssh/id_rsa.
Your public key has been saved in /root/.ssh/id_rsa.pub.
The key fingerprint is:
SHA256:BNIzHPcqCyjjZqWm88s0zqHrj8J8+gUnkF1cNOEDKZs root@modest-galliform.local
The key's randomart image is:
+---[RSA 3072]----+
| o=**o |
| o..+Bo.. |
| o .+ =. . |
| .E ... |
|o .+... S |
|.oo +. o |
|o*+ .. |
|BO.+. |
|*B@+ |
+----[SHA256]-----+A chave privada é salva no local padrão de /root/.ssh/id_rsa e uma senha é definida para segurança adicional.
Para visualizar o conteúdo da chave pública, use cat /root/.ssh/id_rsa.pu.
Por exemplo:
[root@modest-galliform ~]# cat /root/.ssh/id_rsa.pub
ssh-rsa AAAAB3NzaC1yc2EAAAADAQABAAABgQCv6YOgYbRmXCEFxZP+t+pzh/RRKzsgWpvcnmKwF+uwiKDuihHadScCkgd8dE6ymCjP/+UVdVLGEzXfHXG5EfbcPQYOGjqqOGqOVCHIrhFMG3GjSPao99KaDIAvXsWyTDI9FmrXTiC+0WkmOLNb0UeDic+lQ6KJumw12O1niZjC19jMpWR5amRWEJo6oKFylC8JLHsdfhqr7EBcBzvUJkqh/1zY3qcsABHBrBCWOKC5oNiDAzctQ5MeHq6tv6w6YxdZLLdupczteERN6roroySMtR2JZnOIcnq1aUgD/YDJDeg9zpvUN7stsndONYVOH42+bBu7xEWsm8zobgdfLlmhv+8ab7dKVlYvJUkITqCoKpp8m0f3dbLtQSevCJ9qaeQvmxkjU9OHVPkkTolw4aUHvUsutpVynNfmErf3RGMjQRiQ3ZE7xGKVV7iSFDK9l0mMWBHpYu2OnVKQlP823IC0YKD2dP3qDd/nnvGXVlxfRI+C08n9ehoHwZAIz4SM3dU= root@modest-galliform.localCopie a chave inteira. Ela começa com "ssh-rsa" e continua até o final.
Agora de volta à aba Key Pair. Clique em Import Key Pair.
Insira os valores a seguir:
- Key Pair Name: Defina um nome para a chave pública SSH. Este exemplo de chave pública é chamada de
jumpstation-key, mas ela realmente pode ter o nome que você quiser. - Key Type: Este exemplo usa um tipo de chave SSH Key.
- Public Key: Cole aqui a chave pública que você acabou de copiar.
Clique em Import Key Pair.
Depois que a chave pública for importada, crie a instância pressionando Launch Instance (as outras abas estão fora do escopo desta demonstração).
A instância passa por um processo de compilação. Aguarde alguns minutos para que isso ocorra. Quando concluída, a instância aparece na página Instances Listing.
Atribuir e anexar um IP flutuante
A instância criada anteriormente está associada a uma rede privada. Atualmente, a única maneira de acessar essa instância é conectar-se a ela com os nós de hardware da nuvem. Outra opção de conexão é usar um IP flutuante. Nesta seção, demonstramos como alocar um IP flutuante e anexá-lo a esta instância.
Para alocar um IP flutuante, primeiro navegue até Project -> Network -> Floating IPs. Em seguida, clique em Allocate IP to Project.
No pop-up, certifique-se de que Pool esteja definido como External (e, opcionalmente, adicione uma descrição) e clique em Allocate IP para adicionar esse endereço IP flutuante para uso.
Na mesma seção, aloque o IP à instância Jumpstation clicando no botão Associate no canto direito.
Preencha os detalhes:
- IP Address: Este campo vem pré-selecionado com o IP flutuante, então não há necessidade de alterar nada aqui.
- Port to be associated: Selecione a instância criada anteriormente. Neste caso, vamos usar a instância Jumpstation.
Clique em Associate. Essa instância agora pode ser acessada por SSH a partir do primeiro nó de hardware da sua nuvem.
Para se autenticar nesta instância, após se autenticar em seu nó de hardware, execute o seguinte comando [você terá que alterar o endereço IP para o que acabou de associar] :
ssh -i /root/.ssh/id_rsa centos@173.231.255.40
Deve ser algo assim no seu terminal:
[root@modest-galliform ~]# ssh -i /root/.ssh/id_rsa centos@173.231.255.40
The authenticity of host '173.231.255.40 (173.231.255.40)' can't be established.
ECDSA key fingerprint is SHA256:z45zzE8fPuKagtyrSGP9AWR4vIVpBppoaqkqj1Kx4SA.
Are you sure you want to continue connecting (yes/no/[fingerprint])? yes
Warning: Permanently added '173.231.255.40' (ECDSA) to the list of known hosts.
Enter passphrase for key '/root/.ssh/id_rsa':
Activate the web console with: systemctl enable --now cockpit.socket
[centos@jumpstation ~]$ Na seção seguinte, você terá que fazer algo enquanto estiver autenticado nesta máquina.
Como instalar e usar a CLI do OpenStack
Até agora, aprendemos como gerenciar o OpenStack por meio de um navegador da web. Mas também é possível gerenciar através da linha de comando usando a CLI do OpenStack, chamada OpenStackClient.
Usar a linha de comando para gerenciar sua nuvem apresenta mais flexibilidade nas tarefas de automação e, geralmente, pode simplificar a vida de um administrador. Vamos aprender como.
Agora, instalaremos o OpenStackClient na instância que acabamos de criar e que chamamos de Jumpstation.
Antes de instalar o OpenStackClient, você deve obter dois arquivos do Horizon, que são necessários para preparar seu ambiente de shell. Esses dois arquivos são clouds.yaml e o arquivo OpenStack RC.
clouds.yaml: usado como fonte de configuração de como se conectar a uma nuvem- Arquivo OpenStack RC: Usado como fonte de autenticação para seu usuário e projeto
Para coletar esses arquivos, autentique-se no Horizon como seu usuário. Navegue até Project -> API Access. Em seguida, clique em Download OpenStack RC File e baixe os arquivos clouds.yaml e OpenStack RC do OpenStack para sua máquina. Os arquivos são associados ao usuário atual e ao projeto em que o usuário está.
Preparar e instalar o OpenStackClient
Em seguida, use SSH para fazer login na instância criada anteriormente. Se você está acompanhando, essa instância só pode ser acessada de um de seus nós do plano de controle. Use as instruções fornecidas recentemente para fazer login na instância.
Aqui estão as etapas para preparar e instalar o OpenStackClient, depois de se autenticar.
Etapa 1: Preparar arquivos clouds.yaml e OpenStack RC
O arquivo clouds.yaml, obtido anteriormente, deve ser preparado nesta instância. Para esta demonstração, vamos salvá-lo em ~/.config/openstack/clouds.yaml. Teremos que copiar o conteúdo de clouds.yaml que baixamos para nossa máquina do Horizon e armazená-lo como ~/.config/openstack/clouds.yaml.
Aqui está como você cria o diretório e, em seguida, edita o arquivo. Execute os comandos após o $ em sua linha de comando.
# Cria o diretório a seguir
$ mkdir -p ~/.config/openstack
# Cria e abre o clouds.yaml para edição
$ vi ~/.config/openstack/clouds.yaml
Para obter o conteúdo do clouds.yaml do seu computador local para a instância, primeiro você terá que abrir a versão local em um editor de texto. Em seguida, você terá que copiar todo o texto e colá-lo na versão que acabou de criar na instância.
Depois de colar o texto do arquivo no editor vi em seu terminal, use o comando :wq para salvar e sair do editor.
O arquivo clouds.yaml pode ser colocado em vários locais. Para obter mais informações, consulte o tópico Configuration Files (em inglês) da documentação do OpenStack Victoria.
Em seguida, copie o conteúdo do arquivo OpenStack RC de sua máquina local para a instância. O arquivo pode ser colocado em qualquer lugar. Então, para este exemplo, vamos armazená-lo no diretório inicial do usuário. O caminho completo será ~/Development-openrc.sh.
Crie e comece a editar o arquivo com o seguinte comando (não use $ ao copiar e colar o comando).
$ vi ~/Development-openrc.sh
Assim como antes, você terá que abrir a versão local do arquivo, copiar todo o texto e colá-lo na versão de instância do arquivo que está aberto em seu terminal. Em seguida, use o comando :wq para salvar e sair do editor.
Agora, você tem que executar o arquivo. Primeiro, altere as permissões:
$ chmod +x Development-openrc.sh
Em seguida, execute o arquivo:
$ ./Development-openrc.sh
Você terá que inserir sua senha no OpenStack.
Em seguida, execute o comando:
$ source Development-openrc.sh
Etapa 2: Criar um ambiente virtual do Python
Criaremos um ambiente virtual para não interferir na versão Python do sistema.
Em uma instalação padrão do CentOS 8 Stream, o executável Python do sistema é /usr/libexec/platform-python e é o que será usado para criar o ambiente virtual.
Use /usr/libexec/platform-python -m venv ~/venv para criar um ambiente virtual no caminho ~/venv.
Por exemplo:
$ /usr/libexec/platform-python -m venv ~/venv
Etapa 3: Ativar o ambiente virtual do Python
Use source ~/venv/bin/activate para ativar o ambiente virtual.
Por exemplo:
$ source ~/venv/bin/activate
Depois de ativar o ambiente virtual, o nome dele aparecerá no início da linha de comando. Então vai ficar mais ou menos assim:
[centos@jumpstation ~]$ /usr/libexec/platform-python -m venv ~/venv
[centos@jumpstation ~]$ source ~/venv/bin/activate
(venv) [centos@jumpstation ~]$
Etapa 4: Atualizar o pip
Antes de instalar o OpenStackClient e para auxiliar em uma instalação tranquila, atualize o pip. Atualize o pip usando pip install --upgrade pip.
Por exemplo:
$ pip install --upgrade pip
Etapa 5: Instalar o OpenStackClient
Com tudo preparado, o OpenStackClient pode ser instalado.
Observação: há dois pacotes do OpenStackClient: python-openstackclient e openstackclient. Recomendo usar o python-openstackclient, pois ele é mantido com maior frequência que o pacote anterior.
Instale o OpenStackClient usando:
$ pip install python-openstackclient
Etapa 6: Listar servidores associados com o seu projeto
Para um comando inicial, liste os servidores associados com seu projeto executando openstack server list.
Por exemplo:
(venv) [centos@jumpstation ~]$ openstack server list
+--------------------------------------+-------------+--------+---------------------------------------+--------------------------+----------+
| ID | Name | Status | Networks | Image | Flavor |
+--------------------------------------+-------------+--------+---------------------------------------+--------------------------+----------+
| 412fc87f-a4d9-40f1-ba07-fe3eee216c38 | Jumpstation | ACTIVE | Private=173.231.255.40, 192.168.0.140 | N/A (booted from volume) | m1.small |
+--------------------------------------+-------------+--------+---------------------------------------+--------------------------+----------+Agora, podemos ver o servidor criado anteriormente.
Estrutura de comandos
Ao usar o OpenStackClient, normalmente há um padrão de comando comum para o que você deseja realizar. Todos os comandos openstack começam com openstack. Você pode executar o openstack sozinho para entrar em um shell, onde os comandos não precisam mais ser prefixados por openstack:
(venv) [centos@jumpstation ~]# openstack
(openstack)
Listar todos os subcomandos disponíveis
Use openstack --help para listar todos os subcomandos disponíveis. Você inicialmente vê todas as flags que você pode passar, mas, após rolar um pouco para baixo, a lista de subcomandos se inicia:
Commands:
access rule delete Delete access rule(s)
access rule list List access rules
access rule show Display access rule details
access token create Create an access token
acl delete Delete ACLs for a secret or container as identified by its href. (python-barbicanclient)
[...saída truncada...]
Saber mais sobre um subcomando
Depois de ver os comandos disponíveis, aprenda mais sobre um comando usando openstack help <comando>.
Por exemplo, para aprender mais sobre o comando openstack server, use openstack help server:
$ openstack help server
Command "server" matches:
server add fixed ip
server add floating ip
server add network
server add port
server add security group
[...saída truncada...]
Listar itens e mostrar detalhes
É muito comum usar o OpenStackClient para listar itens e o formato de comando, normalmente, é openstack <subcomando> list. Por exemplo, openstack server list lista todos os servidores para o projeto atualmente configurado.
Além disso, mais informações sobre um item podem ser encontradas normalmente executando openstack <subcomando> show <item>. Por exemplo, openstack server show Jumpstation mostra os detalhes sobre a instância chamada Jumpstation.
Como as nuvens privadas são implantadas
Agora, vamos saber mais sobre como sua nuvem privada foi implantada e saber mais sobre o ambiente. O OpenStack pode ser implantado de várias maneiras e esta seção destaca as características de sua nuvem privada. Também explicamos algumas das vantagens desse tipo de implantação e áreas exclusivas do OpenMetal.
No OpenMetal, o OpenStack é conteinerizado por meio do Docker usando o Kolla Ansible. Isso é feito por meio de um contêiner de implantação inicial chamado FM-Deploy. O FM-Deploy fornece as alterações iniciais de configuração durante o processo de provisionamento de sua nuvem privada. O FM-Deploy Container é uma parte necessária da arquitetura atual de sua nuvem privada. O FM-Deploy Container deve permanecer em execução em sua nuvem privada, pois é usado por nossos sistemas caso você queira adicionar ou remover nós de sua nuvem.
Conteinerização do OpenStack
O OpenMetal usa o Kolla Ansible para configurar contêineres do Docker para todos os serviços em execução. Se você precisar fazer alguma alteração de configuração em seus nós, o Kolla Ansible deve ser usado para enviar essas alterações. Se o Kolla Ansible não for usado, existe o risco de essas alterações serem revertidas durante as atualizações do sistema.
Algumas vantagens da conteinerização por meio do docker são:
- Os contêineres criam um ambiente isolado, reduzindo as dependências de software
- Os contêineres podem ser dimensionados e permitem que os serviços sejam balanceados em seu cluster
- Os contêineres oferecem maior flexibilidade para lançamentos de teste, patches e automação
- Os contêineres têm uma implantação consistente e repetível e um tempo de inicialização mais curto
Armazenamento em disco e Ceph
No OpenMetal, o armazenamento em disco é fornecido pelo Ceph. O Ceph é uma interface de armazenamento de objetos que pode fornecer interfaces para vários tipos de armazenamento diferentes em um único cluster. No OpenMetal, o Ceph é composto por dois elementos: armazenamento de objetos e armazenamento de blocos.
O armazenamento de objetos (object storage, em inglês) do Ceph utiliza o daemon Ceph Object Storage Gateway (RADOSGW). Com as nuvens do OpenMetal, o RGW do Ceph substitui o Swift para que não haja contêiner do Docker para o Swift. Em vez disso, os endpoints do Swift são conectados diretamente ao RGW. A autenticação para RGW é feita através do Keystone em /etc/ceph/ceph.conf.
O armazenamento em bloco (block storage, em inglês) do Ceph conecta-se ao serviço Cinder utilizando o dispositivo de bloco RADOS do Ceph. Em sua nuvem, esses objetos são armazenados em pools do Ceph. O Ceph fornece uma camada de abstração que permite que os objetos sejam reconhecidos como blocos.
Algumas vantagens do uso do Ceph são:
- Os dados são autorrecuperáveis e redistribuem os dados em seu cluster em caso de problemas de energia, hardware ou conectividade
- Os dados são replicados e altamente disponíveis
- O Ceph tem a capacidade de rodar em hardware comum e misturar hardware de diferentes fornecedores
Introdução ao Ceph
O Ceph é um sistema de armazenamento distribuído de código aberto que fornece interfaces de armazenamento de objetos, blocos e arquivos a partir de um único cluster.
O Ceph foi selecionado como a solução de armazenamento para nuvens Private Cloud Core OpenStack devido à sua capacidade de armazenar dados de forma replicada. Os dados armazenados no cluster Ceph podem ser acessados de qualquer um dos nós do plano de controle da sua nuvem. O armazenamento é considerado compartilhado entre todos os nós, o que pode tornar trivial a recuperação de uma instância e seus dados.
Vamos aprender como verificar o status do seu cluster Ceph e ver o uso de disco disponível usando a linha de comando.
Verificar status do Ceph
Primeiro, verifique se você está conectado a um dos nós do plano de controle da nuvem (não a uma instância). Para verificar o status do cluster Ceph, use ceph status.
Por exemplo:
[root@modest-galliform ~]# ceph status
cluster:
id: ac5c03ba-fcb8-4963-b235-e9020b5bfcc2
health: HEALTH_OK
services:
mon: 3 daemons, quorum modest-galliform,gifted-badger,hopeful-guineafowl (age 7d)
mgr: hopeful-guineafowl(active, since 7d), standbys: modest-galliform, gifted-badger
osd: 3 osds: 3 up (since 7d), 3 in (since 7d)
rgw: 3 daemons active (gifted-badger.rgw0, hopeful-guineafowl.rgw0, modest-galliform.rgw0)
task status:
data:
pools: 12 pools, 329 pgs
objects: 2.06k objects, 9.4 GiB
usage: 31 GiB used, 2.6 TiB / 2.6 TiB avail
pgs: 329 active+clean
io:
client: 2.2 KiB/s rd, 2 op/s rd, 0 op/s wrVerificar o uso de disco do Ceph
Para verificar o espaço disponível em disco no seu cluster Ceph, use ceph df.
Por exemplo:
[root@modest-galliform ~]# ceph df
--- RAW STORAGE ---
CLASS SIZE AVAIL USED RAW USED %RAW USED
ssd 2.6 TiB 2.6 TiB 28 GiB 31 GiB 1.15
TOTAL 2.6 TiB 2.6 TiB 28 GiB 31 GiB 1.15
--- POOLS ---
POOL ID PGS STORED OBJECTS USED %USED MAX AVAIL
device_health_metrics 1 1 418 KiB 3 1.2 MiB 0 839 GiB
images 2 32 6.8 GiB 921 20 GiB 0.81 839 GiB
volumes 3 32 2.4 GiB 662 7.3 GiB 0.29 839 GiB
vms 4 32 4.2 KiB 6 48 KiB 0 839 GiB
backups 5 32 0 B 0 0 B 0 839 GiB
metrics 6 32 2.1 MiB 242 8.4 MiB 0 839 GiB
manila_data 7 32 0 B 0 0 B 0 839 GiB
manila_metadata 8 32 0 B 0 0 B 0 839 GiB
.rgw.root 9 32 2.4 KiB 6 72 KiB 0 839 GiB
default.rgw.log 10 32 3.4 KiB 207 384 KiB 0 839 GiB
default.rgw.control 11 32 0 B 8 0 B 0 839 GiB
default.rgw.meta 12 8 0 B 0 0 B 0 839 GiB
Mantendo as atualizações de software do OpenStack
O software no ecossistema OpenStack evolui com o tempo, seja por meio de novas adições de recursos, correções de bugs ou quando as vulnerabilidades são corrigidas. Parte da operação de uma nuvem OpenStack envolve a manutenção de seu software por meio de atualizações. Nesta seção, apontamos as seções em uma nuvem OpenMetal, onde ocorrem atualizações de software, e explicamos as práticas recomendadas ao realizar atualizações.
O software de uma nuvem OpenMetal, que pode ser atualizado, inclui o gerenciador de pacotes de cada nó de hardware e as imagens Kolla Ansible Docker. As atualizações do Ceph são tratadas por meio do gerenciador de pacotes do nó.
Agora, abordaremos especificamente a etapa para realizar atualizações do gerenciador de pacotes.
- Migrar a carga de trabalho
As atualizações do gerenciador de pacotes que exigem uma reinicialização do servidor para um nó do plano de controle do OpenMetal podem ser disruptivas para qualquer carga de trabalho executada nele. Antes de executar ações disruptivas, pode ser possível migrar instâncias para outro nó executando o serviço de computação. Para obter informações sobre como migrar instâncias, consulte a documentação do OpenStack Nova.
2. Atualizar um nó por vez
Ao executar atualizações do gerenciador de pacotes, certifique-se de que as atualizações ocorram com sucesso para um nó de hardware antes de atualizar outro nó.
3. Desabilitar o Docker
Antes de atualizar o gerenciador de pacotes, certifique-se de que o soquete do Docker e o serviço no SystemD estejam parados e desabilitados. Por exemplo:
systemctl disable docker.socket
systemctl stop docker.socket
systemctl disable docker.service
systemctl stop docker.service
4. Atualizar pacotes do sistema operacional do hospedeiro
Depois de verificar se o soquete e o serviço do Docker estão parados, execute as atualizações do gerenciador de pacotes:
dnf upgrade
5. Determinar a necessidade de reinicialização
Depois que o gerenciador de pacotes for concluído, verifique se uma reinicialização é necessária com needs-restarting do dnf-utils e o sinalizador de dica de reinicialização (-r):
$ needs-restarting -r
Core libraries or services have been updated since boot-up:
* kernel
* systemd
Reboot is required to fully utilize these updates.
More information: https://access.redhat.com/solutions/27943
$
6. Manutenção do Ceph
Esta etapa é opcional e é necessária apenas se o nó precisa ser reiniciado.
Antes da reinicialização, se o nó fizer parte do cluster Ceph, a remoção automática de OSD e o rebalanceamento de dados devem ser temporariamente suspensos. Para isso, execute:
ceph osd set noout
ceph osd set norebalance
Isso reduzirá o tempo de reconstrução e ajudará a garantir que o nó reingresse no cluster automaticamente.
Depois que o nó for reinicializado e um cluster Ceph íntegro for confirmado, esses parâmetros deverão ser desdefinidos. Para desarmar esta configuração, execute:
ceph osd unset noout
ceph osd unset norebalance
Reinicializar se necessário
Reinicialize o nós se necessário:
shutdown -r now
Você pode ter que aguardar por um minuto ou dois antes de poder se autenticar novamente no nó do plano de controle.
Verificar reinicialização bem-sucedida
Quando o nó voltar a ficar on-line, acesse ele por SSH para verificar se os contêineres do OpenStack Docker foram iniciados. Além disso, se esse nó fazia parte do cluster Ceph, verifique o status do cluster Ceph.
Para verificar se os contêineres do Docker foram iniciados, use docker ps. Você deve ver vários contêineres do Docker em execução. Na coluna STATUS, cada contêiner deve refletir o status Up.
Por exemplo:
[root@modest-galliform ~]# docker ps
CONTAINER ID IMAGE COMMAND CREATED STATUS PORTS NAMES
6f7590bc2191 harbor.imhadmin.net/kolla/centos-binary-telegraf:victoria "dumb-init --single-…" 20 hours ago Restarting (1) 14 seconds ago telegraf
67a4d47e8c78 harbor.imhadmin.net/kolla/centos-binary-watcher-api:victoria "dumb-init --single-…" 3 days ago Up 6 minutes watcher_api
af815b1dcb5d harbor.imhadmin.net/kolla/centos-binary-watcher-engine:victoria "dumb-init --single-…" 3 days ago Up 6 minutes watcher_engine
a52ab61933ac harbor.imhadmin.net/kolla/centos-binary-watcher-applier:victoria "dumb-init --single-…" 3 days ago Up 6 minutes watcher_applier
[...output truncated...]
Em seguida, se esse nó fizer parte de um cluster Ceph, verifique o status do Ceph usando ceph status.
Por exemplo:
[root@modest-galliform ~]# ceph status
cluster:
id: 06bf4555-7c0c-4b96-a3b7-502bf8f6f213
health: HEALTH_OK
[...output truncated...]
A saída acima mostra o status como HEALTH_OK, indicando que o cluster Ceph está íntegro. O Ceph é naturalmente resiliente e deve se recuperar após a reinicialização de um nó.
Ver o uso de recursos da sua nuvem privada
Agora, vamos ver como encontrar o uso de recursos de sua nuvem privada. Exploraremos como utilizar o Horizon Dashboard para determinar o uso total de memória e computação de um projeto, bem como visualizar instâncias armazenadas em cada nó. Em seguida, veremos o uso do disco explicando como interagir brevemente com o cluster Ceph da sua nuvem usando a linha de comando. Por fim, veremos como adicionar e remover nós do cluster Ceph.
Atualmente, existem três variações para implantações de nuvem privada: Small, Standard e Large (pequena, padrão e grande, respectivamente). Todas as implantações de nuvem privada têm um cluster de três servidores hiperconvergentes, mas terão alocações diferentes de memória, armazenamento e poder de processamento da CPU, dependendo da configuração e do hardware. Além disso, você tem a opção de adicionar nós de hardware adicionais ao cluster.
Ver o uso de memória e computação no Horizon
Para visualizar os recursos usados por sua nuvem, você precisa ser o usuário administrador e atribuído ao projeto administrativo. Quando estiver no projeto admin, navegue até Admin -> Compute -> Hypervisors. Esta seção lista os seguintes itens:
- Uso de VCPU
- Use de memória
- Uso de disco local
Ver o estado da instância no cluster
Também há uma opção para ver a localização de suas instâncias em seu cluster. Para visualizar essas informações, navegue até Admin -> Compute -> Instances. Você tem a opção de ver o projeto, o host, bem como o endereço IP e o estado.
Como acessar informações de recursos do Ceph
Para acessar informações sobre os pools de recursos do seu cluster Ceph, você precisará usar a CLI do Ceph. Este é um resumo de alguns comandos úteis de monitoramento e integridade de recursos.
ceph -spara verificar o status do Cephceph dfpara listar a visão geral do uso de discosceph health detailfornece detalhes sobre problemas de integridade existentesceph osd pool lspara listar pools – adicionedetailpara detalhes adicionais sobre métricas de replicação e integridade
Criar e restaurar back-ups de volumes
Com as nuvens privadas, você pode criar back-ups e snapshots de seus dados de volume. Se os dados de um volume forem corrompidos ou removidos por engano, ter uma cópia desses dados pode ser inestimável. Agora, veremos como criar e recuperar back-ups de volume usando o Horizon.
Em primeiro lugar, vamos rever o que é um volume. Volumes são dispositivos de armazenamento em bloco que você anexa a instâncias para habilitar o armazenamento persistente. Você pode anexar um volume a uma instância em execução ou desanexar um volume e anexá-lo a outra instância a qualquer momento. Você também pode criar um instantâneo ou excluir um volume.
Criar o back-up de um volume
Navegue no Horizon até Project -> Volume -> Volumes. Crie um back-up de seu volume selecionando-o a partir do menu suspenso Create Backup. Você vai precisar preencher os campos a seguir.
- Backup Name: Especifique um nome para o back-up do volume
- Description: Forneça uma descrição se necessário
- Container Name: Deixe isso em branco. Do contrário, o back-up do volume não será criado. O Horizon informa que se este campo estiver em branco, o back-up é armazenado em um contêiner chamado
volumebackups, mas esse não é o caso da nossa configuração. Com as nuvens privadas, todos os back-ups de volume criados dessa maneira são armazenados no pool do Ceph chamadobackups. - Backup Snapshot: Se aplicável, especifique um snapshot para criar um back-up
Depois de enviar o formulário, você navega para Project -> Volume -> Volume Backups, onde se pode ver o volume do qual você acabou de criar um back-up.
Testar os back-ups de volume
Criar cópias de back-up de seus dados importantes é apenas uma parte de ter um plano sólido de back-up e recuperação. Além disso, considere testar os dados de back-up para garantir que, se algo inesperado acontecer, é possível restaurar seus back-ups, algo que será realmente útil. Para testar back-ups de volume, você pode restaurar um back-up de volume no OpenStack junto com o volume original e comparar o conteúdo.
Restaurar um back-up de volume
Para restaurar um back-up de volume, comece a navegar no Horizon até Project -> Volume -> Volume Backups.
Em seguida, encontre o back-up de volume que você deseja restaurar e, a partir de seu menu suspenso à direita, selecione Restore Backup. Escolha o volume para o qual restaurar ou faça com que o sistema restaure o back-up em um novo volume.
Ceph, volumes e durabilidade dos dados
Quando os back-ups de volume são criados, eles são armazenados no cluster do Ceph da sua nuvem em um pool chamado backups. Por padrão, o cluster do Ceph é configurado com replicação em nível de host em cada um dos três nós do plano de controle da nuvem. Com essa configuração, sua nuvem pode perder todos os nós do Ceph, exceto um, e ainda reter todos os dados do cluster.
Conclusão
Agora você deve ter um entendimento básico do OpenStack e de algumas das coisas que você pode fazer com ele. Boa sorte na configuração do seu próprio sistema OpenStack.