Cómo utilizar el almacenamiento de objetos Vultr en Go

Introducción

Vultr Object Storage es una solución de almacenamiento de objetos en la nube altamente escalable y compatible con S3 para almacenar archivos u objetos. Esta guía explica cómo usar Vultr Object Storage en Go con GoVultr v2 y cómo administrar depósitos dentro del almacenamiento de objetos con AWS SDK for Go.

requisitos previos

Necesitará:

  • Una estación de trabajo de computadora que se ejecuta en Linux, Windows o macOS
  • La última versión de Go instalada en la estación de trabajo de su computadora

Estos ejemplos usan Linux $ indicador, pero los comandos también funcionan en Mac y Windows.

Administre el almacenamiento de objetos Vultr con Go

  1. Generar un Clave API de tu Configuración de la API por habilitando su API .

    Advertencia: mantenga segura su clave de API. Su clave de API tiene acceso a toda su cuenta de Vultr, y exponer públicamente su clave de API puede comprometer su cuenta.

  2. Cree una nueva carpeta de proyecto.

                              
                                $ mkdir ObjectStorage
    
                              
                            
  3. Cambie el directorio a la nueva carpeta.

                              
                                $ cd ObjectStorage
    
                              
                            
  4. Inicialice el módulo.

                              
                                $ go mod init ObjectStorage
    
                              
                            
  5. Instalar GoVultr v2 .

                              
                                $ go get -u github.com/vultr/govultr/v2
    
                              
                            
  6. Instalar oAuth2 para ir .

                              
                                $ go get golang.org/x/oauth2
    
                              
                            
  7. Configure su clave API como una variable de entorno. Reemplazar YOUR-API-KEY-HERE con su clave API encontrada en su Configuración de la API .

    Las estaciones de trabajo Linux y macOS ejecutan:

                              
                                $ export VULTR_API_KEY=YOUR-API-KEY-HERE
    
                              
                            

    Las estaciones de trabajo de Windows ejecutan:

                              
                                C:\> setx VULTR_API_KEY "YOUR-API-KEY-HERE"
    
                              
                            
  8. Utilice su editor de texto sin formato preferido para crear y editar main.go . Los usuarios de Linux pueden usar nano mientras que los usuarios de Mac y Windows pueden elegir TextEdit o Notepad .

                              
                                $ nano main.go
    
                              
                            
  9. Pegue el siguiente código en main.go que configura la main package e importa todos los paquetes necesarios.

                              
                                package main
    
    import (
        "bufio"
         "context"
         "fmt"
         "log"
         "os"
         "strings"
         "time"
    
         "github.com/vultr/govultr/v2"
         "golang.org/x/oauth2"
    )
    
                              
                            
  10. Pegue el siguiente código en main.go que declara las variables globales.

                              
                                var (
         apiKey       = os.Getenv("VULTR_API_KEY")
         vc           *govultr.Client
         ctx          = context.Background()
         input        int
         input2       string
         loop         string
         objStorageID string
    )
    
                              
                            
  11. Pegue el siguiente código en main.go que inicializa configuración oAuth2 , TokenSource y el Cliente Vultr .

                              
                                func init() {
        config := &oauth2.Config{}
        ts := config.TokenSource(ctx, &oauth2.Token{AccessToken: apiKey})
        vc = govultr.NewClient(oauth2.NewClient(ctx, ts))
    }
    
                              
                            

Gestión de almacenamiento de objetos con GoVultr

Rellene su main.go archivo con cada una de estas funciones. Cada función es para una operación específica de almacenamiento de objetos.

Función: listClusters()

Esta función enumera todos los clústeres de almacenamiento de objetos. Detiene el programa si hay errores al enumerar los clústeres o si no se encuentran clústeres.

                      
                        func listClusters() {
     clusterList, meta, err := vc.ObjectStorage.ListCluster(ctx, nil)
     if err != nil {
          log.Panicf("Error listing clusters: %s", err)
     }
     if meta.Total <= 0 {
          log.Panic("There are no clusters found to create an Object Storage.")
     }
     log.Printf("List of All Clusters: %+v", clusterList)
}

                      
                    

Función: createObjStorage()

Esta función crea un almacenamiento de objetos en su clúster seleccionado, luego imprime su información completa una vez que se vuelve activo . Detiene el programa si hay algún error al crear un almacenamiento de objetos.

Esta guía utiliza ClusterID 2 que es la ubicación de almacenamiento de objetos de Vultr en Nueva Jersey, ewr1.vultrobjects.com .

                      
                        func createObjStorage() {
     var objStorageName string
     clusterID := 2
     fmt.Print("Enter Your Desired Object Storage Name: ")
     scanner := bufio.NewScanner(os.Stdin)
     for scanner.Scan() {
          objStorageName = scanner.Text()
          fmt.Print()
          if objStorageName != "" {
               break
          }
     }
     objStorageNew, errn := vc.ObjectStorage.Create(ctx, clusterID, objStorageName)
     if errn != nil {
          log.Panicf("Error creating storage: %s", errn)
     } else {
          log.Printf("Succesfully created an Object Storage with ID: %s", objStorageNew.ID)
     }
     for {
          objStorageNewInfo, erri := vc.ObjectStorage.Get(ctx, objStorageNew.ID)
          if erri != nil {
               log.Panicf("Error getting Object Storage Information: %s", erri)
          }
          if objStorageNewInfo.Status == "active" {
               log.Print("Your Object Storage is now Active.")
               log.Printf("Object Storage Information: %+v", objStorageNewInfo)
               log.Println("S3 Credentials: ")
               log.Printf("Hostname: %s | Access Key: %s | Secret Key: %s", objStorageNewInfo.S3Hostname, objStorageNewInfo.S3AccessKey, objStorageNewInfo.S3SecretKey)
               break
          }
          log.Printf("The Object Storage is currently %s. Waiting another ten seconds until it becomes active.", objStorageNewInfo.Status)
          time.Sleep(time.Second * 10)
     }
}

                      
                    

La función requiere una entrada de usuario: el nombre deseado del usuario para el almacenamiento de objetos. A continuación, crea un nuevo almacenamiento de objetos y comprueba el estado del almacenamiento de objetos recién creado cada diez segundos hasta que se activa. Una vez que el estado del almacenamiento de objetos se vuelve activo, muestra su información completa.

Funciones: listObjStorage1() y listObjStorage2()

Estas funciones enumeran todo el almacenamiento de objetos en su cuenta. Hay dos formas de mostrar la información de almacenamiento de su objeto.

Primero: enumere todo el almacenamiento de objetos uno por uno, luego muestre los datos en formato JSON.

                      
                        func listObjStorage1() {
     objStorageList, meta, err := vc.ObjectStorage.List(ctx, nil)
     log.Printf("The Total Number of Object Storage: %d", meta.Total)
     for x := 0; x != len(objStorageList); x++ {
          log.Printf("Object Storage #%d:", x+1)
          log.Printf("List of Object Storage: %+v", objStorageList[x])
          log.Println()
     }
     if err != nil {
          log.Panicf("Error listing Object Storage: %s", err)
     }
}

                      
                    

Esta función muestra el número total de almacenamiento de objetos activos en su cuenta y su información completa en formato JSON.

Segundo: enumere todo el almacenamiento de objetos uno por uno, luego muestre los datos de cada almacenamiento de objetos por pares clave-valor.

                      
                        func listObjStorage2() {
     objStorageList, meta, err := vc.ObjectStorage.List(ctx, nil)
     log.Printf("The Total Number of Object Storage: %d", meta.Total)
     for x := 0; x != len(objStorageList); x++ {
          log.Printf("Object Storage #%d:", x+1)
          log.Printf("Date Created: %s", objStorageList[x].DateCreated)
          log.Printf("Object Storage ID: %s", objStorageList[x].ID)
          log.Printf("Object Storage Label: %s", objStorageList[x].Label)
          log.Printf("Object Storage Location: %s", objStorageList[x].Location)
          log.Printf("Object Storage Region: %s", objStorageList[x].Region)
          log.Printf("Object Storage Hostname: %s", objStorageList[x].S3Hostname)
          log.Printf("Object Storage Access Key: %s", objStorageList[x].S3AccessKey)
          log.Printf("Object Storage Secret Key: %s", objStorageList[x].S3SecretKey)
          log.Printf("Object Storage Status: %s", objStorageList[x].Status)
          log.Printf("Object Storage Cluster ID: %d", objStorageList[x].ObjectStoreClusterID)
          log.Println()
     }
     if err != nil {
          log.Panicf("Error listing Object Storage: %s", err)
     }
}

                      
                    

Esta función muestra el número total de almacenamiento de objetos activos en su cuenta y su información completa. los ID de almacenamiento de objetos es necesario cuando desea manipular el almacenamiento de objetos.

Función: getObjStorage()

Esta función muestra la información completa de un almacenamiento de objetos específico o detiene el programa si hay un error al obtener la información de su almacenamiento de objetos.

                      
                        func getObjStorage() {
     fmt.Println("To Get your Object Storage's ID, List all of your Object Storage.")
     fmt.Print("Enter Your Object Storage's ID to get its Full Information (e.g. cb676a46-66fd-4dfb-b839-443f2e6c0b60): ")
     fmt.Scan(&objStorageID)
     objStorageGet, err := vc.ObjectStorage.Get(ctx, objStorageID)
     log.Printf("Full information of Object Storage with an ID \"%s\".", objStorageID)
     log.Printf("Object Storage ID: %s", objStorageGet.ID)
     log.Printf("Date Created: %s", objStorageGet.DateCreated)
     log.Printf("Label: %s", objStorageGet.Label)
     log.Printf("Location: %s", objStorageGet.Location)
     log.Printf("Region: %s", objStorageGet.Region)
     log.Printf("S3 Hostname: %s", objStorageGet.S3Hostname)
     log.Printf("S3 Access Key: %s", objStorageGet.S3AccessKey)
     log.Printf("S3 Secret Key: %s", objStorageGet.S3SecretKey)
     log.Printf("Status: %s", objStorageGet.Status)
     log.Printf("Cluster ID: %d", objStorageGet.ObjectStoreClusterID)
     log.Println()
     if err != nil {
          log.Panicf("Error Getting Object Storage that has an ID %s: %s", objStorageID, err)
     }
}

                      
                    

Esta función requiere una entrada del usuario: la identificación de su almacenamiento de objetos, que puede encontrar cuando enumera todo su almacenamiento de objetos.

Función: delObjStorage()

Esta función elimina un almacenamiento de objetos específico.

                      
                        func delObjStorage() {
     fmt.Println("To Get your Object Storage's ID, List all of your Object Storage.")
     fmt.Print("Enter the ID of the Object Storage that you want to Delete (e.g. cb676a46-66fd-4dfb-b839-443f2e6c0b60): ")
     fmt.Scan(&objStorageID)
     objStorageDel := vc.ObjectStorage.Delete(ctx, objStorageID)
     if objStorageDel == nil {
          log.Printf("Successfully deleted object storage with an ID \"%s\"", objStorageID)
     }
}

                      
                    

Esta función requiere una entrada de usuario: la ID del almacenamiento de objetos que desea eliminar.

Función: actualizarObjetoAlmacenamiento()

Esta función actualiza o cambia la etiqueta de un almacenamiento de objetos específico.

                      
                        func updateObjectStorage() {
     var newLabel string
     fmt.Println("To Get your Object Storage's ID, List all of your Object Storage.")
     fmt.Print("Enter the ID of the Object Storage that you want to Update the Label (e.g. cb676a46-66fd-4dfb-b839-443f2e6c0b60): ")
     fmt.Scan(&objStorageID)
     fmt.Print("Enter Your Desired New Object Storage Label: ")
     scanner := bufio.NewScanner(os.Stdin)
     for scanner.Scan() {
          newLabel = scanner.Text()
          fmt.Print()
          if newLabel != "" {
               break
          }
     }
     objStorageUpdate := vc.ObjectStorage.Update(ctx, objStorageID, newLabel)
     if objStorageUpdate == nil {
          log.Printf("Succesfully updated the label of the object storage with an ID of: \"%s\"", objStorageID)
     }
     fmt.Print()
}

                      
                    

Esta función requiere dos entradas de usuario: la identificación de su almacenamiento de objetos, que puede encontrar cuando enumera todo su almacenamiento de objetos, y su nueva etiqueta preferida de almacenamiento de objetos.

Función regenKeys()

Esta función generará una nueva clave de acceso y clave secreta de un almacenamiento de objetos específico.

                      
                        func regenKeys() {
     fmt.Println("To Get your Object Storage's ID, List all of your Object Storage.")
     fmt.Print("Enter the ID of the Object Storage that you want to Regenerate Keys (e.g. cb676a46-66fd-4dfb-b839-443f2e6c0b60): ")
     fmt.Scan(&objStorageID)
     objStorageNewKeys, err := vc.ObjectStorage.RegenerateKeys(ctx, objStorageID)
     log.Print("Successfully Regenerated new S3 Credentials.")
     log.Printf("Your Object Storage's New S3 Credentials are: %v", objStorageNewKeys)
     log.Printf("S3 Hostname: %s", objStorageNewKeys.S3Hostname)
     log.Printf("S3 Access Key: %s", objStorageNewKeys.S3AccessKey)
     log.Printf("S3 Secret Key: %s", objStorageNewKeys.S3SecretKey)
     if err != nil {
          log.Panicf("Error Regenerating New S3 Credentials: %v", err)
     }
}

                      
                    

Esta función requiere una entrada de usuario: la ID del almacenamiento de objetos para el que desea regenerar las claves.

Función principal

Esta función le pregunta al usuario qué operación de almacenamiento de objetos le gustaría realizar, luego llama a una función específica basada en la entrada del usuario.

                      
                        func main() {
     for {
          fmt.Println("Input '1' to List All Object Storage Clusters.")
          fmt.Println("Input '2' to Create an Object Storage.")
          fmt.Println("Input '3' to List All Object Storage (Less Organized).")
          fmt.Println("Input '4' to List All Object Storage (More Organized).")
          fmt.Println("Input '5' to Get the Full Information of your Object Storage.")
          fmt.Println("Input '6' to Delete an Object Storage.")
          fmt.Println("Input '7' to Update an Object Storage's Label.")
          fmt.Println("Input '8' to Regenerate Access Key and Secret Key of your Object Storage.")
          fmt.Print("Your Input: ")
          fmt.Scan(&input)
          switch input {
          case 1:
               listClusters()
          case 2:
               createObjStorage()
          case 3:
               listObjStorage1()
          case 4:
               listObjStorage2()
          case 5:
               getObjStorage()
          case 6:
               delObjStorage()
          case 7:
               updateObjectStorage()
          case 8:
               regenKeys()
          default:
               fmt.Println("Invalid Input! Please try again.")
               continue
          }

          fmt.Print("Do you want to rerun the program? (y/n): ")
          fmt.Scan(&input2)
          loop = strings.ToLower(input2)
          if loop == "n" {
               fmt.Println("Closing the Program...")
               time.Sleep(2 * time.Second)
               break
          } else if loop == "y" {
               continue
          } else {
               log.Fatal("Invalid Input! Closing the Program.")
               time.Sleep(2 * time.Second)
          }
     }
}

                      
                    

Cree el proyecto de almacenamiento de objetos

Después de haber llenado el main.go archivo con el example código, guardar y close el archivo. Luego, compile el código en un archivo ejecutable binario.

                      
                        $ go build

                      
                    

Ejecute el archivo ejecutable, luego seleccione qué operación de almacenamiento de objetos desea realizar.

                      
                        $ ./ObjectStorage

                      
                    

Operaciones de cubo

Para administrar sus cubos, use el SDK de AWS para Go .

Configurar el entorno del proyecto del cubo

  1. Cree una nueva carpeta de proyecto.

                              
                                $ mkdir Bucket
    
                              
                            
  2. Cambie el directorio a la nueva carpeta.

                              
                                $ cd Bucket
    
                              
                            
  3. Inicialice el módulo.

                              
                                $ go mod init Bucket
    
                              
                            
  4. Instalar SDK de AWS para Go .

                              
                                $ go get github.com/aws/aws-sdk-go
    
                              
                            
  5. Instalar tipo de Mimica . Este paquete es para configurar el tipo de contenido de cada archivo que se cargará.

                              
                                $ go get github.com/gabriel-vasile/mimetype
    
                              
                            
  6. Obtenga la clave de acceso y la clave secreta de su almacenamiento de objetos de sitio web de vultr o enumere todo su almacenamiento de objetos usando el ObjectStorage programa de arriba.

  7. Configure la clave de acceso y la clave secreta de su almacenamiento de objetos como variables de entorno. Reemplazar YOUR-ACCESS-KEY-HERE y YOUR-SECRET-KEY-HERE con la clave de acceso y la clave secreta de su almacenamiento de objetos.

    Las estaciones de trabajo Linux y macOS ejecutan:

                              
                                $ export ACCESS_KEY=YOUR-ACCESS-KEY-HERE
    $ export SECRET_KEY=YOUR-SECRET-KEY-HERE
    
                              
                            

    Las estaciones de trabajo de Windows ejecutan:

                              
                                C:\> setx ACCESS_KEY "YOUR-ACCESS-KEY-HERE"
    C:\> setx SECRET_KEY "YOUR-SECRET-KEY-HERE"
    
                              
                            
  8. Utilice su editor de texto sin formato preferido para crear y editar main.go . Los usuarios de Linux pueden usar nano mientras que los usuarios de Mac y Windows pueden elegir TextEdit o Notepad .

                              
                                $ nano main.go
    
                              
                            
  9. Pegue el siguiente código en main.go que configura la main package e importa todos los paquetes necesarios.

                              
                                package main
    
    import (
         "fmt"
         "io/ioutil"
         "log"
         "os"
         "path"
         "regexp"
         "strings"
         "time"
    
         "github.com/aws/aws-sdk-go/aws"
         "github.com/aws/aws-sdk-go/aws/awserr"
         "github.com/aws/aws-sdk-go/aws/credentials"
         "github.com/aws/aws-sdk-go/aws/session"
         "github.com/aws/aws-sdk-go/service/s3"
         "github.com/gabriel-vasile/mimetype"
    )
    
                              
                            
  10. Pegue el siguiente código en main.go que declara las variables globales.

                              
                                var (
         s3Vultr    *s3.S3
         accessKey  = os.Getenv("ACCESS_KEY")
         secretKey  = os.Getenv("SECRET_KEY")
         bucketName string
         directory  string
         filename   string
         input      int
         input2     string
         loop       string
    )
    
                              
                            
  11. Pegue el siguiente código en main.go que inicializa la sesión de Vultr S3.

                              
                                func init() {
        s3Vultr = s3.New(session.Must(session.NewSession(&aws.Config{
            Region:      aws.String("ewr"),
            Credentials: credentials.NewStaticCredentials(accessKey, secretKey, ""),
            Endpoint:    aws.String("https://ewr1.vultrobjects.com/"),
        })))
    }
    
                              
                            

Operaciones de depósito con AWS SDK for Go

Rellene su main.go archivo con cada una de estas funciones. Cada función es para una operación de depósito específica.

Función: listAllBuckets()

Esta función enumera todos los cubos en su almacenamiento de objetos.

                      
                        func listAllBuckets() (ret *s3.ListBucketsOutput) {
     ret, err := s3Vultr.ListBuckets(&s3.ListBucketsInput{})
     if err != nil {
          panic(err)
     }
     return ret
}

                      
                    

Función: createBucket()

Esta función tiene dos funciones auxiliares, nameCheck() y newBucket() . Crea un depósito en su almacenamiento de objetos o detiene el programa si el nombre del depósito ya existe. Requiere una entrada del usuario: su nombre preferido para su depósito. Si su nombre de depósito de entrada no cumple con los criterios para nombrar un depósito, le pedirá que vuelva a ingresar otro nombre de depósito.

                      
                        func nameCheck(str string) bool {
     checker := regexp.MustCompile(`^[a-z0-9-]*$`).MatchString(str)
     alphanumeric := "abcdefghijklmnopqrstuvwxyz1234567890"
     if checker && strings.Contains(alphanumeric, string(str[0])) && len(str) >= 3 && len(str) <= 63 {
          return true
     } else {
          return false
     }
}

func newBucket() (ret *s3.CreateBucketOutput) {
     _, err := s3Vultr.CreateBucket(&s3.CreateBucketInput{
          Bucket: aws.String(bucketName),
          CreateBucketConfiguration: &s3.CreateBucketConfiguration{
               LocationConstraint: aws.String(""),
          },
     })
     if awsError, ok := err.(awserr.Error); ok {
          if awsError.Code() == s3.ErrCodeBucketAlreadyExists {
               log.Fatalf("Bucket %q already exists. Error: %v", bucketName, awsError.Code())
          }
     } else {
          log.Printf("Successfully created bucket %q", bucketName)
     }
     return ret
}

func createBucket() (ret *s3.CreateBucketOutput) {
     for {
          fmt.Println("Bucket names are unique to their location and must meet the following criteria:")
          fmt.Println("Only lowercase and starts with a letter or number. No spaces.")
          fmt.Println("Bucket name may contain dashes")
          fmt.Println("Must be between 3 and 63 characters long.")
          fmt.Print("Enter your preferred Name for the Bucket: ")
          fmt.Scan(&bucketName)
          if nameCheck(bucketName) {
               break
          } else {
               fmt.Printf("%q does not meet the criteria above. Please try again.", bucketName)
               fmt.Print("\n\n")
               continue
          }
     }
     bucketList := listAllBuckets()
     if len(bucketList.Buckets) != 0 {
          for _, bucket := range bucketList.Buckets {
               if bucketName == *bucket.Name {
                    log.Fatalf("Bucket %q already exists and is owned by you.", bucketName)
               } else {
                    newBucket()
                    break
               }
          }
     } else {
          newBucket()
     }
     return ret
}

                      
                    

los createBucket() La función verifica si el nombre de su depósito de entrada ya existe y es de su propiedad, luego llama al nameCheck() función y la newBucket() función.

los nameCheck() La función verifica el nombre del depósito de entrada del usuario para ver si cumple con los criterios para nombrar un depósito y vuelve a preguntar si no es así. utiliza el regexp paquete para verificar si la entrada solo contiene letras minúsculas, números y guiones. Para verificar si la entrada comienza con una letra o un número, utiliza el strings paquete strings.Contains() . También verifica si la longitud de entrada está entre 3 y 63 caracteres.

los newBucket() La función intenta crear un nuevo depósito si el nombre del depósito de entrada no existe y, de lo contrario, devuelve un error.

Función: subirObjeto()

Esta función carga un archivo o un objeto a un depósito específico. Requiere tres entradas de usuario: el nombre del depósito donde desea almacenar el archivo, la ruta o el directorio donde desea colocar los archivos en el depósito y, por último, la ruta del archivo que desea cargar.

                      
                        func uploadObject() (ret *s3.PutObjectOutput) {
     fmt.Print("Enter the name of the bucket where you want to upload the File/Object: ")
     fmt.Scan(&bucketName)
     fmt.Print("Enter the Path or Directory where you want to upload the File/Object in the bucket: (e.g., assets/css/): ")
     fmt.Scan(&directory)
     fmt.Print("Enter the Path to the file that you want to upload (e.g., css/styles.css): ")
     fmt.Scan(&filename)

     f, err := os.Open(filename)
     if err != nil {
          panic(err)
     }
     var mtype2 string
     if strings.Contains(filename, ".css") {
          mtype2 = "text/css"
     } else {
          mtype, errmime := mimetype.DetectFile(filename)
          if errmime != nil {
               log.Fatalf("Error getting Content-Type: %v", errmime)
          }
          mtype2 = mtype.String()
     }

     log.Println("Uploading Object:", filename)
     ret, err = s3Vultr.PutObject(&s3.PutObjectInput{
          Body:        f,
          Bucket:      aws.String(bucketName),
          Key:         aws.String(path.Join(directory, strings.Split(filename, "https://www.vultr.com/")[strings.Count(filename, "https://www.vultr.com/")])),
          ACL:         aws.String("public-read"),
          ContentType: aws.String(mtype2),
     })

     if err != nil {
          panic(err)
     } else {
          log.Printf("File %q was Uploaded Successfully.", filename)
     }
     return ret
}

                      
                    

tu archivo Lista de control de acceso enlatada (ACL) se establece en privado por defecto, lo que significa que nadie excepto usted tiene acceso a él. Para servir sus archivos adecuadamente, debe Otorgar acceso público de lectura y configure el tipo de contenido de su archivo correctamente. El campo ACL con el valor public-read concede a todos los usuarios una LEER acceso y el propietario un CONTROL TOTAL . Cuando carga archivos en su depósito, el tipo de contenido predeterminado suele ser application/octet-stream . Para establecer automáticamente el tipo de contenido de su archivo, el programa utilizó el tipo de Mimica paquete para detectar cada archivo Tipo MIME o tipo de contenido . Ver esta lista de tipos MIME admitidos para tu referencia. Darse cuenta de CSS no está en la lista de tipos MIME admitidos, por lo que se configura mediante strings.Contains() . Si el nombre del archivo tiene un .css extensión, establece el tipo de contenido en text/css .

Función: listaObjetos()

Esta función enumera todos los archivos u objetos en un depósito. Requiere una entrada del usuario: el nombre del depósito para enumerar sus archivos.

                      
                        func listObjects() (ret *s3.ListObjectsV2Output) {
     fmt.Print("Enter the name of the bucket to list its file/s: ")
     fmt.Scan(&bucketName)
     ret, err := s3Vultr.ListObjectsV2(&s3.ListObjectsV2Input{
          Bucket: aws.String(bucketName),
     })

     if err != nil {
          panic(err)
     }
     return ret
}

                      
                    

Función: obtenerObjeto()

Esta función descarga un archivo o un objeto de un cubo en el mismo directorio donde está su main.go o el archivo ejecutable binario es. Requiere tres entradas de usuario: el nombre del depósito, el directorio o la ruta del archivo y el nombre del archivo que desea descargar.

                      
                        func getObject() {
     fmt.Print("Enter the name of the bucket that contains the file that you want to download: ")
     fmt.Scan(&bucketName)
     fmt.Print("Enter the Path or Directory of the file (e.g. assets/css/): ")
     fmt.Scan(&directory)
     fmt.Print("Enter the name of the file that you want to download(e.g., styles.css): ")
     fmt.Scan(&filename)
     log.Println("Downloading: ", filename)

     ret, err := s3Vultr.GetObject(&s3.GetObjectInput{
          Bucket: aws.String(bucketName),
          Key:    aws.String(path.Join(directory, strings.Split(filename, "https://www.vultr.com/")[strings.Count(filename, "https://www.vultr.com/")])),
     })

     if err != nil {
          panic(err)
     }

     body, _ := ioutil.ReadAll(ret.Body)
     err = ioutil.WriteFile(filename, body, 0644)
     if err != nil {
          panic(err)
     }
     log.Println("File Downloaded Successfully.")
}

                      
                    

Esta función lee el archivo dentro de un cubo usando ioutil.ReadAll() luego escribe los datos devueltos usando ioutil.WriteFile() . Guarda el archivo como filename con un 644 permiso, lo que significa que el propietario tiene Lee y escribe acceso, mientras que el grupo y los demás sólo tienen Leer acceso.

Función: eliminarObjeto()

Esta función elimina un archivo o un objeto de un depósito. Requiere tres entradas de usuario: el nombre del depósito que contiene el archivo que desea eliminar, la ruta o el directorio del archivo en el depósito y el nombre del archivo que desea eliminar.

                      
                        func deleteObject() (ret *s3.DeleteObjectOutput) {
     fmt.Print("Enter the name of the bucket that contains the file that you want to delete: ")
     fmt.Scan(&bucketName)
     fmt.Print("Enter the Path or Directory of the file in the bucket (e.g., assets/css/): ")
     fmt.Scan(&directory)
     fmt.Print("Enter the name of the file that you want to delete (e.g., styles.css): ")
     fmt.Scan(&filename)
     log.Println("Deleting: ", filename)
     ret, err := s3Vultr.DeleteObject(&s3.DeleteObjectInput{
          Bucket: aws.String(bucketName),
          Key:    aws.String(path.Join(directory, strings.Split(filename, "https://www.vultr.com/")[strings.Count(filename, "https://www.vultr.com/")])),
     })

     if err != nil {
          panic(err)
     } else {
          log.Printf("%q deleted Successfully", filename)
     }
     return ret
}

                      
                    

Función: eliminarTodosObjetos()

Esta función elimina todos los archivos u objetos en un depósito. Requiere una entrada de usuario: El Nombre del cubo que quieres vaciar. Esta función puede ser útil cuando desea eliminar un depósito, ya que debe eliminar todo su contenido antes de poder eliminarlo.

                      
                        func deleteAllObjects() {
     fmt.Scan(&bucketName)
     objectList, errList := s3Vultr.ListObjectsV2(&s3.ListObjectsV2Input{
          Bucket: aws.String(bucketName),
     })
     if errList != nil {
          log.Fatalf("Error Listing objects: %v", errList)
     }
     for _, object := range objectList.Contents {
          log.Printf("Deleting %v", *object.Key)
          _, err := s3Vultr.DeleteObject(&s3.DeleteObjectInput{
               Bucket: aws.String(bucketName),
               Key:    aws.String(*object.Key),
          })
          log.Printf("%v Deleted Successfully", *object.Key)
          if err != nil {
               log.Fatalf("Error Deleteing Objects.")
          }
     }
     log.Println("All Files deleted successfully.")
}

                      
                    

Esta función enumera primero todo el contenido del depósito y luego obtiene el Llave de cada objeto que se utilizará para eliminar cada archivo.

Función: deleteBucket()

Esta función elimina un depósito de su almacenamiento de objetos. Requiere una entrada del usuario: el nombre del depósito que desea eliminar.

                      
                        func deleteBucket() (ret *s3.DeleteBucketOutput) {
     deleteAllObjects()
     ret, err := s3Vultr.DeleteBucket(&s3.DeleteBucketInput{
          Bucket: aws.String(bucketName),
     })
     if err != nil {
          if awsError, ok := err.(awserr.Error); ok {
               switch awsError.Code() {
               case s3.ErrCodeNoSuchBucket:
                    log.Fatalf("No Bucket exists with the name '%s'", bucketName)
                    log.Println()
               default:
                    panic(err)
               }
          }
     }
     log.Printf("Bucket %q deleted Successfully.", bucketName)
     return ret
}

                      
                    

Esta función llama al deleteAllObjects() primero para eliminar todo su contenido porque debe vaciar el depósito antes de poder eliminarlo.

Función principal del cubo

los main() La función le pregunta al usuario qué operación de depósito le gustaría realizar, luego llama a una función específica basada en la entrada del usuario.

                      
                        func main() {
     for {
          fmt.Println("Input '1' to List All Buckets in your Object Storage.")
          fmt.Println("Input '2' to Create a new Bucket.")
          fmt.Println("Input '3' to Delete a Bucket.")
          fmt.Println("Input '4' to Upload a File/Object.")
          fmt.Println("Input '5' to List All Files/Objects inside a Bucket.")
          fmt.Println("Input '6' to Download a File/Object from a Bucket.")
          fmt.Println("Input '7' to Delete a File/Object from a Bucket.")
          fmt.Println("Input '8' to Delete All Files/Objects from a Bucket.")
          fmt.Print("Your Input: ")
          fmt.Scan(&input)
          switch input {
          case 1:
               log.Println(listAllBuckets())
          case 2:
               createBucket()
          case 3:
               fmt.Print("Enter the Name of the Bucket that you want to Delete: ")
               deleteBucket()
          case 4:
               uploadObject()
          case 5:
               log.Println(listObjects())
          case 6:
               getObject()
          case 7:
               deleteObject()
          case 8:
               fmt.Print("Enter the Name of the Bucket that you want to Empty: ")
               deleteAllObjects()
          default:
               log.Println("Invalid Input! Please try again.")
               continue
          }

          fmt.Print("Do you want to rerun the program? (y/n): ")
          fmt.Scan(&input2)
          loop = strings.ToLower(input2)
          if loop == "n" {
               fmt.Println("Closing the Program...")
               time.Sleep(2 * time.Second)
               break
          } else if loop == "y" {
               continue
          } else {
               log.Fatalln("Invalid Input! Closing the Program.")
               time.Sleep(2 * time.Second)
          }
     }
}

                      
                    

Construya el proyecto del cubo

Después de haber llenado el main.go archivo con el example código, guardar y close el archivo. Luego, compile el código en un archivo ejecutable binario.

                      
                        $ go build

                      
                    

Ejecute el archivo ejecutable, luego seleccione qué operación de depósito desea realizar.

                      
                        $ ./Bucket

                      
                    

Servicio de archivos estáticos con almacenamiento de objetos Vultr

Debe hacer dos cosas importantes para servir archivos estáticos con Vultr Object Storage. Primero, tienes que Otorgar acceso público de lectura a todos tus archivos estáticos . Y segundo, necesitas establecer el tipo de contenido correcto para cada archivo o sus archivos se descargarán cuando visite la URL de sus archivos estáticos.

En esto examplecreará archivos estáticos HTML y CSS de muestra y los alojará con Vultr Object Storage.

  1. Usarás el mismo proyecto. Bucket y el mismo archivo ejecutable Bucket.exe para crear un depósito y cargar archivos porque su configuración (ACL enlatada y tipo de contenido) está configurada para otorgar acceso público de lectura y para configurar el tipo de contenido automáticamente.

                              
                                $ cd Bucket
    
                              
                            
  2. Cree un archivo HTML llamado index.html .

                              
                                $ nano index.html
    
                              
                            
  3. Pegue este código HTML de muestra en su index.html archivo, luego guarde y salga del archivo.

                              
                                <!DOCTYPE html>
    <html >
    <head>
        <link rel="stylesheet" href="#">
        <meta name="viewport" content="width=device-width, initial-scale=1.0">
        <title>This is a Sample Static File Hosted with Vultr Object Storage</title>
    </head>
    <body>
        <h1>This is a Heading 1</h1>
        <h2>This is a Heading 2</h2>
        <h3>This is a Heading 3</h3>
        <h4>This is a Heading 4</h4>
        <h5>This is a Heading 5</h5>
        <h6>This is a Heading 6</h6>
        <p>This is a Sample Static File Hosted with Vultr Object Storage.</p>
    </body>
    </html>
    
                              
                            
  4. Crear una carpeta llamada css .

  5. Crea un archivo CSS llamado style.css dentro de css carpeta.

                              
                                $ nano css/style.css
    
                              
                            
  6. Pegue este código CSS de muestra en su style.css archivo, luego guarde y salga del archivo.

                              
                                h1 {color: blue;}
    h2 {color: red;}
    h3 {color: green;}
    h4 {background-color: blue;}
    h5 {background-color: red;}
    h6 {background-color: green;}
    
                              
                            
  7. Ejecute el archivo ejecutable binario Bucket.exe .

                              
                                $ ./Bucket
    
                              
                            
  8. Crear un nuevo cubo. Enter 2 para crear un nuevo depósito, luego nombre el depósito como my-static-hosting o cualquier nombre de depósito que prefiera.

    Aquí está la ejecución de muestra:

                              
                                Input '1' to List All Buckets in your Object Storage.
    Input '2' to Create a new Bucket.
    Input '3' to Delete a Bucket.
    Input '4' to Upload a File/Object.
    Input '5' to List All Files/Objects inside a Bucket.
    Input '6' to Download a File/Object from a Bucket.
    Input '7' to Delete a File/Object from a Bucket.
    Input '8' to Delete All Files/Objects from a Bucket.
    Your Input: 2
    Bucket names are unique to their location and must meet the following criteria:
    Only lowercase and starts with a letter or number. No spaces.
    Bucket name may contain dashes
    Must be between 3 and 63 characters long.
    Enter your preferred name for the Bucket: my-static-hosting
    2022/07/29 17:31:45 Successfully created bucket "my-static-hosting"
    Do you want to rerun the program? (y/n): n
    Closing the Program...
    
                              
                            
  9. Sube tu index.html archivo y style.css expediente. Correr Bucket.exe de nuevo, luego ingrese 4 para cargar un archivo. Vuelva a ejecutar el programa cuando se le solicite porque tiene que cargar dos archivos.

    Aquí está la ejecución del programa de muestra:

                              
                                $ ./Bucket
    
    Input '1' to List All Buckets in your Object Storage.
    Input '2' to Create a new Bucket.
    Input '3' to Delete a Bucket.
    Input '4' to Upload a File/Object.
    Input '5' to List All Files/Objects inside a Bucket.
    Input '6' to Download a File/Object from a Bucket.
    Input '7' to Delete a File/Object from a Bucket.
    Input '8' to Delete All Files/Objects from a Bucket.
    Your Input: 4
    Enter the name of the bucket where you want to upload the File/Object: my-static-hosting
    Enter the Path or Directory where you want to upload the File/Object in the bucket: (e.g., assets/css/): /
    Enter the Path to the file that you want to upload (e.g., css/styles.css): index.html
    2022/07/29 17:36:03 Uploading Object: index.html
    2022/07/29 17:36:04 File "index.html" was Uploaded Successfully.
    Do you want to rerun the program? (y/n): y
    Input '1' to List All Buckets in your Object Storage.
    Input '2' to Create a new Bucket.
    Input '3' to Delete a Bucket.
    Input '4' to Upload a File/Object.
    Input '5' to List All Files/Objects inside a Bucket.
    Input '6' to Download a File/Object from a Bucket.
    Input '7' to Delete a File/Object from a Bucket.
    Input '8' to Delete All Files/Objects from a Bucket.
    Your Input: 4
    Enter the name of the bucket where you want to upload the File/Object: my-static-hosting
    Enter the Path or Directory where you want to upload the File/Object in the bucket: (e.g., assets/css/): css/
    Enter the Path to the file that you want to upload (e.g., css/styles.css): css/style.css
    2022/07/29 17:36:16 Uploading Object: css/style.css
    2022/07/29 17:36:17 File "css/style.css" was Uploaded Successfully.
    Do you want to rerun the program? (y/n): n
    Closing the Program...
    
                              
                            
  10. En su navegador web, vaya a https://bucketname.ewr1.vultrobjects.com/filename . Para example, https://my-static-hosting.ewr1.vultrobjects.com/index.html .

  11. Tenga en cuenta que sus archivos HTML estáticos se muestran y no se descargan cuando visita la URL del archivo. La hoja de estilo CSS vinculada también se aplica.
  12. Puede cargar otros tipos de medios, como imágenes, videos, etc., para probar aún más el servicio de archivos estáticos con Vultr Object Storage.

Más información

Para obtener más información sobre Vultr Object Storage, GoVultr V2, Vultr API v2 y AWS SDK for Go, consulte estos recursos:

Título del artículo Nombre (opcional) Correo electrónico (opcional) Descripción

Enviar sugerencia

Related Posts