Lista de chaves de API
Chaves de API para acessar seu projeto.
API
Serverspace Public API - uma API pública para interação com os serviços do Serverspace. As ações executadas no painel de controle do Serverspace também podem ser executadas usando a API pública.
Autorização
Para trabalhar com a API pública, crie uma chave de API para o projeto e passe-a no cabeçalho X-API-KEY em cada solicitação. Por exemplo, ao usar o utilitário cURL, o cabeçalho teria a seguinte aparência:
-H "X-API-KEY: lmGwbvllpIqIrKROOCLgE5Z941MKP5EYfbkgwtqJZGigfXUTpuYRpNQkCqShmm6r"Todas as solicitações de API devem ser feitas por meio de HTTPS. Aqui está o URL do ponto de extremidade da API pública:
https://api.serverspace.io/
Exemplos de uso
Vamos obter informações sobre o projeto enviando uma solicitação usando o utilitário cURL:
curl -X GET
https://api.serverspace.io/api/v1/project
-H 'content-type: application/json'
-H 'x-api-key: lmGwbvllpIqIrKROOCLgE5Z941MKP5EYfbkgwtqJZGigfXUTpuYRpNQkCqShmm6r'Isso retornará informações sobre o projeto:
{
"project": {
"balance": 400.07,
"created": "2019-04-08T10:35:53.7021047Z",
"currency": "EUR",
"id": 1,
"state": "Active"
}
}Vamos criar um servidor com a seguinte configuração: Amsterdã, nome: "api-example", sistema operacional Debian 10.7, configuração do servidor - 1 GB de RAM, 1 CPU, unidade de inicialização SSD de 25 GB, 50 Mbps:
curl -X POST
https://api.serverspace.io/api/v1/servers
-H 'content-type: application/json'
-H 'x-api-key: lmGwbvllpIqIrKROOCLgE5Z941MKP5EYfbkgwtqJZGigfXUTpuYRpNQkCqShmm6r'
-d '{
"location_id": "am2",
"image_id": "Debian-10.7-X64",
"cpu": 1,
"ram_mb": 1024,
"volumes": [
{
"name": "boot",
"size_mb": 25600
}
],
"networks": [
{
"bandwidth_mbps": 50
}
],
"name": "api-example"
}'O resultado retorna um ID de tarefa, que pode ser usado para rastrear o processo de criação do servidor:
{
"task_id" : "lt1507097"
}CLI
O s2ctl é um Serverspace na linha de comando. A CLI lhe dá a capacidade de controlar sua infraestrutura por meio do terminal, assim como no painel de controle. A ferramenta está disponível em nosso Github.
Instalação
O s2ctl está disponível para Linux e Windows como um arquivo binário separado. Baixe o arquivo do Github e descompacte-o.
Instalação no Linux
- Baixe o arquivo do repositório do GitHub:
wget https://github.com/itglobalcom/s2ctl/releases/download/vX.X.X/s2ctl-vX.X.X-linux.tar.gzX.X.X.X é o número da versão mais recente do utilitário.
- Descompacte o arquivo baixado:
tar -xzf s2ctl-vX.X.X-linux.tar.gz - Navegue até o diretório criado e execute o utilitário s2ctl:
cd s2ctl-vX.X.X-linux
./s2ctl --help - (Opcional) Você também pode adicionar o diretório que contém o executável s2ctl à variável de ambiente $PATH para acessar o utilitário de qualquer lugar do sistema operacional. Para ver o que está na variável $PATH neste momento, digite o comando:
echo $PATHPara adicionar um novo diretório à lista, use o comando:
export PATH=$PATH:"" A variável $PATH é definida pelo shell sempre que ele é iniciado, mas você pode fazer com que ele inclua o caminho para o utilitário em cada novo shell que abrir. O método exato depende do shell que você está usando.
Por exemplo, no bash, você precisa adicionar a seguinte linha sobre o arquivo correspondente:echo 'export PATH=$PATH:""' >> .bashrc Use o comando para aplicar as alterações:
source ~/.bashrc
Instalação no Windows
- Baixe o arquivo s2ctl-vX.X.X-windows.zip de Github e descompacte-o.
- Execute a linha de comando:
- Pressione Win+R ou Iniciar → Pesquisar → Digite run → OK
- Insira o comando cmd → OK
- Por padrão, a linha de comando exibe o diretório inicial do usuário atual. Navegue até o diretório com o arquivo extraído:
cd - Vá para o diretório desejado e execute o comando:
s2ctl --help- (Opcional) Você também pode adicionar o diretório onde colocou o binário s2ctl à variável de ambiente PATH para acessar o utilitário de qualquer lugar do sistema operacional.
- Encontre System (Painel de controle) em Search e abra-o.
- Clique em Configurações avançadas do sistema.
- Clique em Variáveis de ambiente. Na seção System Variables (Variáveis do sistema), localize a variável PATH e selecione-a. Clique em Editar. Se a variável PATH não existir, clique em New.
- Na janela Edit System Variable (ou New System Variable), especifique o valor da variável de ambiente PATH. Clique em OK. Feche todas as janelas restantes clicando em OK.
Autorização
Para trabalhar com a CLI, você deve criar uma chave de API para o projeto e também um contexto. Caso contrário, você precisará passar a chave de API em cada solicitação.
Criação de contexto
O uso de contextos simplifica o uso do utilitário s2ctl. Nesse caso, você não precisa especificar explicitamente a chave de API para cada comando.
Para criar um contexto, use o seguinte comando:
s2ctl context create -k -n Por exemplo:
s2ctl context create -k lmGwbvllpIqIrKROOCLgE5Z941MKP5EYfbkgwtqJZGigfXUTpuYRpNQkCqShmm6r -n exampleTransferência de chave
Para passar a chave da API explicitamente, ela deve ser especificada no final do comando com a opção --apikey:
s2ctl Por exemplo:
s2ctl images --apikey lmGwbvllpIqIrKROOCLgE5Z941MKP5EYfbkgwtqJZGigfXUTpuYRpNQkCqShmm6rExemplos de uso
Obtenha informações sobre o projeto com o seguinte comando:
s2ctl project showIsso retornará informações sobre o projeto:
id: '1'
balance: '400.24'
currency: EUR
state: Active
created: '2019-04-08T10:35:53.7021047Z'Criar servidor:
s2ctl server create --name test-cli --location nj3 --image Ubuntu-20.04-X64 --cpu 2 --ram 2048M --volume boot:30720M --volume volume:10240M --public-network 50 --public-network 60Isso retornará o ID da tarefa, que pode ser usado para rastrear o processo de criação do servidor:
task_id: lt1512053Terraform
O Serverspace do provedor Terraform permite que você gerencie recursos de nuvem usando a abordagem Infraestrutura como código. O gerenciamento é feito usando arquivos de configuração especiais nos quais você descreve o estado desejado da sua infraestrutura.
Instalando o Terraform
Primeiro, vamos instalar o Terraform em seu sistema operacional. Recomendamos usar o manual do desenvolvedor do Terraform.
Configuração do provedor
- Crie uma chave de API para o projeto que funcionará com o Terraform.
- Crie e navegue até o diretório que será usado para trabalhar com o Terraform Provider.
- Crie e abra o arquivo de configuração provider.tf.
- Insira as informações do provedor no arquivo, onde
é sua chave de API, e salve as alterações:
terraform {
required_providers {
serverspace = {
source = "itglobalcom/serverspace"
version = "0.2.0"
}
}
}
variable "s2_token" {
type = string
default = ""
}
provider "serverspace" {
key = var.s2_token
} Abra um prompt de comando e navegue até o diretório em que você criou o arquivo. Execute uma inicialização para verificar se ela está correta:
terraform initVocê verá a seguinte mensagem se a inicialização for bem-sucedida:
Initializing the backend...
Initializing provider plugins...
- Finding itglobalcom/serverspace versions matching "0.2.0"...
- Installing itglobalcom/serverspace v0.2.0...
- Installed itglobalcom/serverspace v0.2.0 (self-signed, key ID 062XXXXXXXXXXXX)
Partner and community providers are signed by their developers.
If you'd like to know more about provider signing, you can read about it here: https://www.terraform.io/docs/cli/plugins/signing.html
Terraform has created a lock file .terraform.lock.hcl to record the provider selections it made above. Include this file in your version control repository so that Terraform can guarantee to make the same selections by default when you run "terraform init" in the future.
Terraform has been successfully initialized!
You may now begin working with Terraform. Try running "terraform plan" to see any changes that are required for your infrastructure. All Terraform commands should now work.
If you ever set or change modules or backend configuration for Terraform, rerun this command to reinitialize your working directory. If you forget, other commands will detect it and remind you to do so if necessary.Descrição de sua infraestrutura
Com o Serverspace Terraform Provider, você pode criar uma infraestrutura com várias configurações. Você pode encontrar a documentação detalhada no Terraform Registry.
Vamos dar uma olhada no exemplo de criação de uma infraestrutura simples com dois servidores conectados por meio de uma rede isolada:
- Servidor em Amsterdã chamado "server-1" com sistema operacional Ubuntu 20.04. Configuração do servidor - 2 GB de RAM, 2 CPUs, unidade de inicialização SSD de 40 GB, unidade SSD adicional de 20 GB, 50 Mbit/s. Conexão SSH com o servidor. Armazenamento de dados Redis instalado no servidor.
- Servidor em Amsterdã chamado "server-2" com sistema operacional Ubuntu 20.04. Configuração do servidor - 8 GB de RAM, 4 CPUs, unidade de inicialização SSD de 40 GB, 70 Mbps.
- Rede isolada em Amsterdã com endereço 192.168.0.0/24
Siga as etapas abaixo para configurar essa infraestrutura:
- Crie e abra o arquivo ssh_key.tf, que conterá a parte pública da chave ssh para criar o servidor.
- Insira as informações sobre a parte pública da chave ssh no arquivo ssh_key.tf e salve as alterações, substituindo o conteúdo da variável public_key pelo seu valor:
resource "serverspace_ssh" "terraform" {
name = "terraform-key"
public_key = "ssh-rsa AAAAB3Nza...JUDjlM= root@CentOS.local"
}
variable "pvt_key" {
type = string
default = ""
} - Crie e abra o arquivo main.tf que conterá a descrição da infraestrutura.
- Insira a descrição de sua infraestrutura no arquivo.
resource "serverspace_server" "server1" {
image = "Ubuntu-20.04-X64"
name = "server-1"
location = "am2"
cpu = 2
ram = 2048
boot_volume_size = 40*1024
volume {
name = "bar"
size = 20*1024
}
nic {
network = ""
network_type = "PublicShared"
bandwidth = 50
}
nic {
network = resource.serverspace_isolated_network.my_net.id
network_type = "Isolated"
bandwidth = 0
}
ssh_keys = [
resource.serverspace_ssh.terraform.id,
]
connection {
host = self.public_ip_addresses[0]
user = "root"
type = "ssh"
private_key = file(var.pvt_key)
timeout = "2m"
}
provisioner "remote-exec" {
inline = [
"export PATH=$PATH:/usr/bin",
"sudo apt-get update",
"sudo apt-get install -y redis-server",
"exit 0"
]
}
}
resource "serverspace_server" "server2" {
image = "Ubuntu-20.04-X64"
name = "server-2"
location = "am2"
cpu = 4
ram = 8192
boot_volume_size = 40*1024
nic {
network = ""
network_type = "PublicShared"
bandwidth = 70
}
nic {
network = resource.serverspace_isolated_network.my_net.id
network_type = "Isolated"
bandwidth = 0
}
}
resource "serverspace_isolated_network" "my_net" {
location = "am2"
name = "my_net"
description = "Example for Terraform"
network_prefix = "192.168.0.0"
mask = 24
}- Para criar a infraestrutura descrita acima, execute o comando:
terraform applySerá exibida uma janela de diálogo:
Terraform used the selected providers to generate the following execution plan.
Resource actions are indicated with the following symbols:
+ create
Terraform will perform the following actions:
# serverspace_isolated_network.my_net will be created
+ resource "serverspace_isolated_network" "my_net" {
+ description = "Example for Terraform"
+ id = (known after apply)
+ location = "am2"
+ mask = 24
+ name = "my_net"
+ network_prefix = "192.168.0.0"
}
# serverspace_server.server1 will be created
+ resource "serverspace_server" "server1" {
+ boot_volume_id = (known after apply)
+ boot_volume_size = 40960
+ cpu = 2
+ id = (known after apply)
+ image = "Ubuntu-20.04-X64"
+ location = "am2"
+ name = "server-1"
+ public_ip_addresses = (known after apply)
+ ram = 2048
+ ssh_keys = (known after apply)
+ nic {
+ bandwidth = 0
+ id = (known after apply)
+ ip_address = (known after apply)
+ network = (known after apply)
+ network_type = "Isolated"
}
+ nic {
+ bandwidth = 50
+ id = (known after apply)
+ ip_address = (known after apply)
+ network_type = "PublicShared"
}
+ volume {
+ id = (known after apply)
+ name = "bar"
+ size = 20480
}
}
# serverspace_server.server2 will be created
+ resource "serverspace_server" "server2" {
+ boot_volume_id = (known after apply)
+ boot_volume_size = 40960
+ cpu = 4
+ id = (known after apply)
+ image = "Ubuntu-20.04-X64"
+ location = "am2"
+ name = "server-2"
+ public_ip_addresses = (known after apply)
+ ram = 8192
+ ssh_keys = (known after apply)
+ nic {
+ bandwidth = 0
+ id = (known after apply)
+ ip_address = (known after apply)
+ network = (known after apply)
+ network_type = "Isolated"
}
+ nic {
+ bandwidth = 70
+ id = (known after apply)
+ ip_address = (known after apply)
+ network_type = "PublicShared"
}
}
# serverspace_ssh.terraform will be created
+ resource "serverspace_ssh" "terraform" {
+ id = (known after apply)
+ name = "terraform-key"
+ public_key = "ssh-rsa AAAAB3Nza...JUDjlM= root@CentOS.local"
}
Plan: 4 to add, 0 to change, 0 to destroy.
Do you want to perform these actions?
Terraform will perform the actions described above.
Only 'yes' will be accepted to approve.- Digite yes para criar a infraestrutura.
Enter a value: yes
serverspace_ssh.terraform: Creating...
serverspace_isolated_network.my_net: Creating...
serverspace_ssh.terraform: Creation complete after 1s [id=3181]
serverspace_isolated_network.my_net: Creation complete after 8s [id=l2n403]
serverspace_server.server2: Creating...
serverspace_server.server1: Creating...
serverspace_server.server1: Still creating... [10s elapsed]
serverspace_server.server2: Still creating... [10s elapsed]
...
serverspace_server.server1 (remote-exec): (Reading database ...
serverspace_server.server1 (remote-exec): (Reading database ... 5%
serverspace_server.server1 (remote-exec): (Reading database ... 10%
...
serverspace_server.server1: Creation complete after 1m3s [id=l2s190038]
Apply complete! Resources: 4 added, 0 changed, 0 destroyed.- Para exibir a infraestrutura atual, execute o comando:
terraform show- Isso exibirá a configuração atual da infraestrutura:
# serverspace_isolated_network.my_net:
resource "serverspace_isolated_network" "my_net" {
description = "Example for Terraform"
id = "l2n403"
location = "am2"
mask = 24
name = "my_net"
network_prefix = "192.168.0.0"
}
# serverspace_server.server1:
resource "serverspace_server" "server1" {
boot_volume_id = 58909
boot_volume_size = 40960
cpu = 2
id = "l2s190038"
image = "Ubuntu-20.04-X64"
location = "am2"
name = "server-1"
public_ip_addresses = [
"45.138.24.19",
]
ram = 2048
ssh_keys = [
3181,
]
nic {
bandwidth = 0
id = 59576
ip_address = "192.168.0.1"
network = "l2n403"
network_type = "Isolated"
}
nic {
bandwidth = 50
id = 59575
ip_address = "45.138.24.19"
network_type = "PublicShared"
}
volume {
id = 58910
name = "bar"
size = 20480
}
}
# serverspace_server.server2:
resource "serverspace_server" "server2" {
boot_volume_id = 58911
boot_volume_size = 40960
cpu = 4
id = "l2s190039"
image = "Ubuntu-20.04-X64"
location = "am2"
name = "server-2"
public_ip_addresses = [
"31.44.3.68",
]
ram = 8192
ssh_keys = []
nic {
bandwidth = 0
id = 59578
ip_address = "192.168.0.2"
network = "l2n403"
network_type = "Isolated"
}
nic {
bandwidth = 70
id = 59577
ip_address = "31.44.3.68"
network_type = "PublicShared"
}
}
# serverspace_ssh.terraform:
resource "serverspace_ssh" "terraform" {
id = "3181"
name = "terraform-key"
public_key = "ssh-rsa AAAAB3Nza...JUDjlM= root@CentOS.local"
}Parabéns por sua primeira infraestrutura como uma implementação de código.
