This example is a quick-starter and demonstrates how to get started using the Azure Blob Storage SDK for Go.
package main
import (
"context"
"fmt"
"io"
"log"
"os"
"strings"
"github.com/Azure/azure-sdk-for-go/sdk/azcore/to"
"github.com/Azure/azure-sdk-for-go/sdk/storage/azblob"
)
func handleError(err error) {
if err != nil {
log.Fatal(err.Error())
}
}
func main() {
// Your account name and key can be obtained from the Azure Portal.
accountName, ok := os.LookupEnv("AZURE_STORAGE_ACCOUNT_NAME")
if !ok {
panic("AZURE_STORAGE_ACCOUNT_NAME could not be found")
}
accountKey, ok := os.LookupEnv("AZURE_STORAGE_PRIMARY_ACCOUNT_KEY")
if !ok {
panic("AZURE_STORAGE_PRIMARY_ACCOUNT_KEY could not be found")
}
cred, err := azblob.NewSharedKeyCredential(accountName, accountKey)
handleError(err)
// The service URL for blob endpoints is usually in the form: http(s)://<account>.blob.core.windows.net/
client, err := azblob.NewClientWithSharedKeyCredential(fmt.Sprintf("https://%s.blob.core.windows.net/", accountName), cred, nil)
handleError(err)
// ===== 1. Create a container =====
containerName := "testcontainer"
containerCreateResp, err := client.CreateContainer(context.TODO(), containerName, nil)
handleError(err)
fmt.Println(containerCreateResp)
// ===== 2. Upload and Download a block blob =====
blobData := "Hello world!"
blobName := "HelloWorld.txt"
uploadResp, err := client.UploadStream(context.TODO(),
containerName,
blobName,
strings.NewReader(blobData),
&azblob.UploadStreamOptions{
Metadata: map[string]*string{"Foo": to.Ptr("Bar")},
Tags: map[string]string{"Year": "2022"},
})
handleError(err)
fmt.Println(uploadResp)
// Download the blob's contents and ensure that the download worked properly
blobDownloadResponse, err := client.DownloadStream(context.TODO(), containerName, blobName, nil)
handleError(err)
// Use the bytes.Buffer object to read the downloaded data.
// RetryReaderOptions has a lot of in-depth tuning abilities, but for the sake of simplicity, we'll omit those here.
reader := blobDownloadResponse.Body
downloadData, err := io.ReadAll(reader)
handleError(err)
if string(downloadData) != blobData {
log.Fatal("Uploaded data should be same as downloaded data")
}
err = reader.Close()
if err != nil {
return
}
// ===== 3. List blobs =====
// List methods returns a pager object which can be used to iterate over the results of a paging operation.
// To iterate over a page use the NextPage(context.Context) to fetch the next page of results.
// PageResponse() can be used to iterate over the results of the specific page.
pager := client.NewListBlobsFlatPager(containerName, nil)
for pager.More() {
resp, err := pager.NextPage(context.TODO())
handleError(err)
for _, v := range resp.Segment.BlobItems {
fmt.Println(*v.Name)
}
}
// Delete the blob.
_, err = client.DeleteBlob(context.TODO(), containerName, blobName, nil)
handleError(err)
// Delete the container.
_, err = client.DeleteContainer(context.TODO(), containerName, nil)
handleError(err)
}
This example shows how to perform operations on blob conditionally.
package main
import (
"context"
"fmt"
"log"
"os"
"strings"
"time"
"github.com/Azure/azure-sdk-for-go/sdk/azcore"
"github.com/Azure/azure-sdk-for-go/sdk/azcore/streaming"
"github.com/Azure/azure-sdk-for-go/sdk/azcore/to"
"github.com/Azure/azure-sdk-for-go/sdk/storage/azblob"
"github.com/Azure/azure-sdk-for-go/sdk/storage/azblob/blob"
"github.com/Azure/azure-sdk-for-go/sdk/storage/azblob/blockblob"
)
func handleError(err error) {
if err != nil {
log.Fatal(err.Error())
}
}
func main() {
accountName, accountKey := os.Getenv("AZURE_STORAGE_ACCOUNT_NAME"), os.Getenv("AZURE_STORAGE_ACCOUNT_KEY")
credential, err := azblob.NewSharedKeyCredential(accountName, accountKey)
handleError(err)
blockBlob, err := blockblob.NewClientWithSharedKeyCredential(fmt.Sprintf("https://%s.blob.core.windows.net/mycontainer/Data.txt", accountName), credential, nil)
handleError(err)
// This function displays the results of an operation
showResult := func(response *blob.DownloadStreamResponse, err error) {
if err != nil {
log.Fatalf("Failure: %s\n", err.Error())
} else {
err := response.Body.Close()
if err != nil {
log.Fatal(err)
}
// The client must close the response body when finished with it
fmt.Printf("Success: %v\n", response)
}
// Close the response
if err != nil {
return
}
fmt.Printf("Success: %v\n", response)
}
showResultUpload := func(response blockblob.UploadResponse, err error) {
if err != nil {
log.Fatalf("Failure: %s\n", err.Error())
}
fmt.Printf("Success: %v\n", response)
}
// Create the blob
upload, err := blockBlob.Upload(context.TODO(), streaming.NopCloser(strings.NewReader("Text-1")), nil)
showResultUpload(upload, err)
// Download blob content if the blob has been modified since we uploaded it (fails):
downloadResp, err := blockBlob.DownloadStream(
context.TODO(),
&azblob.DownloadStreamOptions{
AccessConditions: &blob.AccessConditions{
ModifiedAccessConditions: &blob.ModifiedAccessConditions{
IfModifiedSince: upload.LastModified,
},
},
},
)
showResult(&downloadResp, err)
// Download blob content if the blob hasn't been modified in the last 24 hours (fails):
downloadResp, err = blockBlob.DownloadStream(
context.TODO(),
&azblob.DownloadStreamOptions{
AccessConditions: &blob.AccessConditions{
ModifiedAccessConditions: &blob.ModifiedAccessConditions{
IfUnmodifiedSince: to.Ptr(time.Now().UTC().Add(time.Hour * -24))},
},
},
)
showResult(&downloadResp, err)
// Upload new content if the blob hasn't changed since the version identified by ETag (succeeds):
showResultUpload(blockBlob.Upload(
context.TODO(),
streaming.NopCloser(strings.NewReader("Text-2")),
&blockblob.UploadOptions{
AccessConditions: &blob.AccessConditions{
ModifiedAccessConditions: &blob.ModifiedAccessConditions{IfMatch: upload.ETag},
},
},
))
// Download content if it has changed since the version identified by ETag (fails):
downloadResp, err = blockBlob.DownloadStream(
context.TODO(),
&azblob.DownloadStreamOptions{
AccessConditions: &blob.AccessConditions{
ModifiedAccessConditions: &blob.ModifiedAccessConditions{IfNoneMatch: upload.ETag}},
})
showResult(&downloadResp, err)
// Upload content if the blob doesn't already exist (fails):
showResultUpload(blockBlob.Upload(
context.TODO(),
streaming.NopCloser(strings.NewReader("Text-3")),
&blockblob.UploadOptions{
AccessConditions: &blob.AccessConditions{
ModifiedAccessConditions: &blob.ModifiedAccessConditions{IfNoneMatch: to.Ptr(azcore.ETagAny)},
},
}))
}
This example shows how to download a large stream with intelligent retries. Specifically, if the connection fails while reading, continuing to read from this stream initiates a new GetBlob call passing a range that starts from the last byte successfully read before the failure.
package main
import (
"context"
"fmt"
"io"
"log"
"os"
"github.com/Azure/azure-sdk-for-go/sdk/azcore/streaming"
"github.com/Azure/azure-sdk-for-go/sdk/storage/azblob"
"github.com/Azure/azure-sdk-for-go/sdk/storage/azblob/blob"
)
func handleError(err error) {
if err != nil {
log.Fatal(err.Error())
}
}
func main() {
// From the Azure portal, get your Storage account blob service URL endpoint.
accountName, accountKey := os.Getenv("AZURE_STORAGE_ACCOUNT_NAME"), os.Getenv("AZURE_STORAGE_ACCOUNT_KEY")
// Create a blobClient object to a blob in the container (we assume the container & blob already exist).
blobURL := fmt.Sprintf("https://%s.blob.core.windows.net/mycontainer/BigBlob.bin", accountName)
credential, err := azblob.NewSharedKeyCredential(accountName, accountKey)
handleError(err)
blobClient, err := blob.NewClientWithSharedKeyCredential(blobURL, credential, nil)
handleError(err)
contentLength := int64(0) // Used for progress reporting to report the total number of bytes being downloaded.
// Download returns an intelligent retryable stream around a blob; it returns an io.ReadCloser.
dr, err := blobClient.DownloadStream(context.TODO(), nil)
handleError(err)
rs := dr.Body
// NewResponseBodyProgress wraps the GetRetryStream with progress reporting; it returns an io.ReadCloser.
stream := streaming.NewResponseProgress(
rs,
func(bytesTransferred int64) {
fmt.Printf("Downloaded %d of %d bytes.\n", bytesTransferred, contentLength)
},
)
defer func(stream io.ReadCloser) {
err := stream.Close()
if err != nil {
log.Fatal(err)
}
}(stream) // The client must close the response body when finished with it
file, err := os.Create("BigFile.bin") // Create the file to hold the downloaded blob contents.
handleError(err)
defer func(file *os.File) {
err := file.Close()
if err != nil {
}
}(file)
written, err := io.Copy(file, stream) // Write to the file by reading from the blob (with intelligent retries).
handleError(err)
fmt.Printf("Wrote %d bytes.\n", written)
}
package main
import (
"context"
"fmt"
"log"
"os"
"github.com/Azure/azure-sdk-for-go/sdk/azcore/to"
"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
"github.com/Azure/azure-sdk-for-go/sdk/storage/azblob"
)
func handleError(err error) {
if err != nil {
log.Fatal(err.Error())
}
}
func main() {
accountName, ok := os.LookupEnv("AZURE_STORAGE_ACCOUNT_NAME")
if !ok {
panic("AZURE_STORAGE_ACCOUNT_NAME could not be found")
}
serviceURL := fmt.Sprintf("https://%s.blob.core.windows.net/", accountName)
cred, err := azidentity.NewDefaultAzureCredential(nil)
handleError(err)
client, err := azblob.NewClient(serviceURL, cred, nil)
handleError(err)
resp, err := client.CreateContainer(context.TODO(), "testcontainer", &azblob.CreateContainerOptions{
Metadata: map[string]*string{"hello": to.Ptr("world")},
})
handleError(err)
fmt.Println(resp)
}
package main
import (
"context"
"fmt"
"log"
"os"
"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
"github.com/Azure/azure-sdk-for-go/sdk/storage/azblob"
)
func handleError(err error) {
if err != nil {
log.Fatal(err.Error())
}
}
func main() {
accountName, ok := os.LookupEnv("AZURE_STORAGE_ACCOUNT_NAME")
if !ok {
panic("AZURE_STORAGE_ACCOUNT_NAME could not be found")
}
serviceURL := fmt.Sprintf("https://%s.blob.core.windows.net/", accountName)
cred, err := azidentity.NewDefaultAzureCredential(nil)
handleError(err)
client, err := azblob.NewClient(serviceURL, cred, nil)
handleError(err)
resp, err := client.DeleteBlob(context.TODO(), "testcontainer", "testblob", nil)
handleError(err)
fmt.Println(resp)
}
package main
import (
"context"
"fmt"
"log"
"os"
"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
"github.com/Azure/azure-sdk-for-go/sdk/storage/azblob"
)
func handleError(err error) {
if err != nil {
log.Fatal(err.Error())
}
}
func main() {
accountName, ok := os.LookupEnv("AZURE_STORAGE_ACCOUNT_NAME")
if !ok {
panic("AZURE_STORAGE_ACCOUNT_NAME could not be found")
}
serviceURL := fmt.Sprintf("https://%s.blob.core.windows.net/", accountName)
cred, err := azidentity.NewDefaultAzureCredential(nil)
handleError(err)
client, err := azblob.NewClient(serviceURL, cred, nil)
handleError(err)
resp, err := client.DeleteContainer(context.TODO(), "testcontainer", nil)
handleError(err)
fmt.Println(resp)
}
package main
import (
"context"
"fmt"
"log"
"os"
"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
"github.com/Azure/azure-sdk-for-go/sdk/storage/azblob"
)
func handleError(err error) {
if err != nil {
log.Fatal(err.Error())
}
}
func main() {
// Set up file to download the blob to
destFileName := "test_download_file.txt"
destFile, err := os.Create(destFileName)
handleError(err)
defer func(destFile *os.File) {
err = destFile.Close()
handleError(err)
}(destFile)
accountName, ok := os.LookupEnv("AZURE_STORAGE_ACCOUNT_NAME")
if !ok {
panic("AZURE_STORAGE_ACCOUNT_NAME could not be found")
}
serviceURL := fmt.Sprintf("https://%s.blob.core.windows.net/", accountName)
cred, err := azidentity.NewDefaultAzureCredential(nil)
handleError(err)
client, err := azblob.NewClient(serviceURL, cred, nil)
handleError(err)
// Perform download
_, err = client.DownloadFile(context.TODO(), "testcontainer", "virtual/dir/path/"+destFileName, destFile,
&azblob.DownloadFileOptions{
// If Progress is non-nil, this function is called periodically as bytes are uploaded.
Progress: func(bytesTransferred int64) {
fmt.Println(bytesTransferred)
},
})
// Assert download was successful
handleError(err)
}
accountName, ok := os.LookupEnv("AZURE_STORAGE_ACCOUNT_NAME")
if !ok {
panic("AZURE_STORAGE_ACCOUNT_NAME could not be found")
}
serviceURL := fmt.Sprintf("https://%s.blob.core.windows.net/", accountName)
cred, err := azidentity.NewDefaultAzureCredential(nil)
handleError(err)
client, err := azblob.NewClient(serviceURL, cred, nil)
handleError(err)
// Download the blob
downloadResponse, err := client.DownloadStream(ctx, "testcontainer", "test_download_stream.bin", nil)
handleError(err)
// Assert that the content is correct
actualBlobData, err := io.ReadAll(downloadResponse.Body)
handleError(err)
fmt.Println(len(actualBlobData))
package main
import (
"fmt"
"log"
"os"
"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
"github.com/Azure/azure-sdk-for-go/sdk/storage/azblob"
)
func handleError(err error) {
if err != nil {
log.Fatal(err.Error())
}
}
func main() {
// this example uses Azure Active Directory (AAD) to authenticate with Azure Blob Storage
accountName, ok := os.LookupEnv("AZURE_STORAGE_ACCOUNT_NAME")
if !ok {
panic("AZURE_STORAGE_ACCOUNT_NAME could not be found")
}
serviceURL := fmt.Sprintf("https://%s.blob.core.windows.net/", accountName)
// https://pkg.go.dev/github.com/Azure/azure-sdk-for-go/sdk/azidentity#DefaultAzureCredential
cred, err := azidentity.NewDefaultAzureCredential(nil)
handleError(err)
client, err := azblob.NewClient(serviceURL, cred, nil)
handleError(err)
fmt.Println(client.URL())
}
package main
import (
"fmt"
"log"
"os"
"github.com/Azure/azure-sdk-for-go/sdk/storage/azblob"
)
func handleError(err error) {
if err != nil {
log.Fatal(err.Error())
}
}
func main() {
// this example uses a connection string to authenticate with Azure Blob Storage
connectionString, ok := os.LookupEnv("AZURE_STORAGE_CONNECTION_STRING")
if !ok {
log.Fatal("the environment variable 'AZURE_STORAGE_CONNECTION_STRING' could not be found")
}
serviceClient, err := azblob.NewClientFromConnectionString(connectionString, nil)
handleError(err)
fmt.Println(serviceClient.URL())
}
package main
import (
"fmt"
"log"
"os"
"github.com/Azure/azure-sdk-for-go/sdk/storage/azblob"
)
func handleError(err error) {
if err != nil {
log.Fatal(err.Error())
}
}
func main() {
// this example uses a shared key to authenticate with Azure Blob Storage
accountName, ok := os.LookupEnv("AZURE_STORAGE_ACCOUNT_NAME")
if !ok {
panic("AZURE_STORAGE_ACCOUNT_NAME could not be found")
}
accountKey, ok := os.LookupEnv("AZURE_STORAGE_ACCOUNT_KEY")
if !ok {
panic("AZURE_STORAGE_ACCOUNT_KEY could not be found")
}
serviceURL := fmt.Sprintf("https://%s.blob.core.windows.net/", accountName)
// shared key authentication requires the storage account name and access key
cred, err := azblob.NewSharedKeyCredential(accountName, accountKey)
handleError(err)
serviceClient, err := azblob.NewClientWithSharedKeyCredential(serviceURL, cred, nil)
handleError(err)
fmt.Println(serviceClient.URL())
}
package main
import (
"context"
"fmt"
"log"
"os"
"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
"github.com/Azure/azure-sdk-for-go/sdk/storage/azblob"
)
func handleError(err error) {
if err != nil {
log.Fatal(err.Error())
}
}
func main() {
// Set up file to upload
fileSize := 8 * 1024 * 1024
fileName := "test_upload_file.txt"
fileData := make([]byte, fileSize)
err := os.WriteFile(fileName, fileData, 0666)
handleError(err)
// Open the file to upload
fileHandler, err := os.Open(fileName)
handleError(err)
// close the file after it is no longer required.
defer func(file *os.File) {
err = file.Close()
handleError(err)
}(fileHandler)
// delete the local file if required.
defer func(name string) {
err = os.Remove(name)
handleError(err)
}(fileName)
accountName, ok := os.LookupEnv("AZURE_STORAGE_ACCOUNT_NAME")
if !ok {
panic("AZURE_STORAGE_ACCOUNT_NAME could not be found")
}
serviceURL := fmt.Sprintf("https://%s.blob.core.windows.net/", accountName)
cred, err := azidentity.NewDefaultAzureCredential(nil)
handleError(err)
client, err := azblob.NewClient(serviceURL, cred, nil)
handleError(err)
// Upload the file to a block blob
_, err = client.UploadFile(context.TODO(), "testcontainer", "virtual/dir/path/"+fileName, fileHandler,
&azblob.UploadFileOptions{
BlockSize: int64(1024),
Concurrency: uint16(3),
// If Progress is non-nil, this function is called periodically as bytes are uploaded.
Progress: func(bytesTransferred int64) {
fmt.Println(bytesTransferred)
},
})
handleError(err)
}
package main
import (
"bytes"
"context"
"fmt"
"log"
"os"
"github.com/Azure/azure-sdk-for-go/sdk/azcore/to"
"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
"github.com/Azure/azure-sdk-for-go/sdk/storage/azblob"
)
func handleError(err error) {
if err != nil {
log.Fatal(err.Error())
}
}
func main() {
accountName, ok := os.LookupEnv("AZURE_STORAGE_ACCOUNT_NAME")
if !ok {
panic("AZURE_STORAGE_ACCOUNT_NAME could not be found")
}
serviceURL := fmt.Sprintf("https://%s.blob.core.windows.net/", accountName)
cred, err := azidentity.NewDefaultAzureCredential(nil)
handleError(err)
client, err := azblob.NewClient(serviceURL, cred, nil)
handleError(err)
// Set up test blob
containerName := "testcontainer"
bufferSize := 8 * 1024 * 1024
blobName := "test_upload_stream.bin"
blobData := make([]byte, bufferSize)
blobContentReader := bytes.NewReader(blobData)
// Perform UploadStream
resp, err := client.UploadStream(context.TODO(), containerName, blobName, blobContentReader,
&azblob.UploadStreamOptions{
Metadata: map[string]*string{"hello": to.Ptr("world")},
})
// Assert that upload was successful
handleError(err)
fmt.Println(resp)
}
package main
import (
"fmt"
"log"
"github.com/Azure/azure-sdk-for-go/sdk/storage/azblob"
)
func handleError(err error) {
if err != nil {
log.Fatal(err.Error())
}
}
func main() {
// this example uses anonymous access to access a public blob
serviceClient, err := azblob.NewClientWithNoCredential("https://azurestoragesamples.blob.core.windows.net/samples/cloud.jpg", nil)
handleError(err)
fmt.Println(serviceClient.URL())
}
package main
import (
"bytes"
"context"
"fmt"
"log"
"os"
"strings"
"github.com/Azure/azure-sdk-for-go/sdk/azcore/streaming"
"github.com/Azure/azure-sdk-for-go/sdk/azcore/to"
"github.com/Azure/azure-sdk-for-go/sdk/storage/azblob"
"github.com/Azure/azure-sdk-for-go/sdk/storage/azblob/blob"
"github.com/Azure/azure-sdk-for-go/sdk/storage/azblob/blockblob"
"github.com/Azure/azure-sdk-for-go/sdk/storage/azblob/container"
)
func handleError(err error) {
if err != nil {
log.Fatal(err.Error())
}
}
func main() {
// Create a credentials object with your Azure Storage Account name and key.
accountName, accountKey := os.Getenv("AZURE_STORAGE_ACCOUNT_NAME"), os.Getenv("AZURE_STORAGE_ACCOUNT_KEY")
credential, err := azblob.NewSharedKeyCredential(accountName, accountKey)
handleError(err)
// From the Azure portal, get your Storage account blob service URL endpoint.
containerURL := fmt.Sprintf("https://%s.blob.core.windows.net/mycontainer", accountName)
// Create an serviceClient object that wraps the service URL and a request pipeline to making requests.
containerClient, err := container.NewClientWithSharedKeyCredential(containerURL, credential, nil)
handleError(err)
// Here's how to create a blob with HTTP headers and metadata (I'm using the same metadata that was put on the container):
blobClient := containerClient.NewBlockBlobClient("Data.bin")
// requestBody is the stream of data to write
requestBody := streaming.NopCloser(strings.NewReader("Some text to write"))
// Wrap the request body in a RequestBodyProgress and pass a callback function for progress reporting.
requestProgress := streaming.NewRequestProgress(streaming.NopCloser(requestBody), func(bytesTransferred int64) {
fmt.Printf("Wrote %d of %d bytes.", bytesTransferred, requestBody)
})
_, err = blobClient.Upload(context.TODO(), requestProgress, &blockblob.UploadOptions{
HTTPHeaders: &blob.HTTPHeaders{
BlobContentType: to.Ptr("text/html; charset=utf-8"),
BlobContentDisposition: to.Ptr("attachment"),
},
})
handleError(err)
// Here's how to read the blob's data with progress reporting:
get, err := blobClient.DownloadStream(context.TODO(), nil)
handleError(err)
// Wrap the response body in a ResponseBodyProgress and pass a callback function for progress reporting.
responseBody := streaming.NewResponseProgress(
get.Body,
func(bytesTransferred int64) {
fmt.Printf("Read %d of %d bytes.", bytesTransferred, *get.ContentLength)
},
)
downloadedData := &bytes.Buffer{}
_, err = downloadedData.ReadFrom(responseBody)
if err != nil {
return
}
err = responseBody.Close()
if err != nil {
return
}
fmt.Printf("Downloaded data: %s\n", downloadedData.String())
}
This section is empty.
This section is empty.
AccessConditions identifies blob-specific access conditions which you optionally set.
CPKInfo contains a group of parameters for client provided encryption key.
CPKScopeInfo contains a group of parameters for the ContainerClient.Create method.
Client represents a URL to an Azure Storage blob; the blob may be a block blob, append blob, or page blob.
NewClient creates an instance of Client with the specified values.
NewClientFromConnectionString creates an instance of Client with the specified values.
NewClientWithNoCredential creates an instance of Client with the specified values. This is used to anonymously access a storage account or with a shared access signature (SAS) token.
NewClientWithSharedKeyCredential creates an instance of Client with the specified values.
CreateContainer is a lifecycle method to creates a new container under the specified account. If the container with the same name already exists, a ContainerAlreadyExists Error will be raised. This method returns a client with which to interact with the newly created container.
DeleteContainer is a lifecycle method that marks the specified container for deletion. The container and any blobs contained within it are later deleted during garbage collection. If the container is not found, a ResourceNotFoundError will be raised.
DownloadBuffer downloads an Azure blob to a buffer with parallel.
DownloadFile downloads an Azure blob to a local file. The file would be truncated if the size doesn't match.
ServiceClient returns the embedded service client for this client.
URL returns the URL endpoint used by the BlobClient object.
UploadBuffer uploads a buffer in blocks to a block blob.
UploadFile uploads a file in blocks to a block blob.
UploadStream copies the file held in io.Reader to the Blob at blockBlobClient. A Context deadline or cancellation will cause this to error.
ClientOptions contains the optional parameters when creating a Client.
CreateContainerOptions contains the optional parameters for the ContainerClient.Create method.
CreateContainerResponse contains the response from method container.Client.Create.
DeleteBlobOptions contains the optional parameters for the Client.Delete method.
DeleteBlobResponse contains the response from method blob.Client.Delete.
DeleteContainerOptions contains the optional parameters for the container.Client.Delete method.
DeleteContainerResponse contains the response from method container.Client.Delete
DeleteSnapshotsOptionType defines values for DeleteSnapshotsOptionType.
PossibleDeleteSnapshotsOptionTypeValues returns the possible values for the DeleteSnapshotsOptionType const type.
DownloadBufferOptions identifies options used by the DownloadBuffer and DownloadFile functions.
DownloadFileOptions identifies options used by the DownloadBuffer and DownloadFile functions.
DownloadStreamOptions contains the optional parameters for the Client.DownloadStream method.
DownloadStreamResponse wraps AutoRest generated BlobDownloadResponse and helps to provide info for retry.
HTTPRange defines a range of bytes within an HTTP resource, starting at offset and ending at offset+count. A zero-value HTTPRange indicates the entire resource. An HTTPRange which has an offset and zero value count indicates from the offset to the resource's end.
ListBlobsFlatOptions contains the optional parameters for the container.Client.ListBlobFlatSegment method.
ListBlobsFlatResponse contains the response from method container.Client.ListBlobFlatSegment.
ListBlobsFlatSegmentResponse - An enumeration of blobs
ListBlobsInclude indicates what additional information the service should return with each blob.
ListContainersInclude indicates what additional information the service should return with each container.
ListContainersOptions contains the optional parameters for the container.Client.ListContainers operation
ListContainersResponse contains the response from method service.Client.ListContainersSegment.
ListContainersSegmentResponse - An enumeration of containers
ObjectReplicationPolicy are deserialized attributes
PublicAccessType defines values for AccessType - private (default) or blob or container.
PossiblePublicAccessTypeValues returns the possible values for the PublicAccessType const type.
RetryReaderOptions contains properties which can help to decide when to do retry.
SharedKeyCredential contains an account's name and its primary or secondary key.
NewSharedKeyCredential creates an immutable SharedKeyCredential containing the storage account's name and either its primary or secondary key.
URLParts object represents the components that make up an Azure Storage Container/Blob URL. NOTE: Changing any SAS-related field requires computing a new SAS signature.
ParseURL parses a URL initializing URLParts' fields including any SAS-related & snapshot query parameters. Any other query parameters remain in the UnparsedParams field. This method overwrites all fields in the URLParts object.
UploadBufferOptions provides set of configurations for UploadBuffer operation
UploadBufferResponse contains the response from method Client.UploadBuffer/Client.UploadFile.
UploadFileOptions provides set of configurations for UploadFile operation
UploadFileResponse contains the response from method Client.UploadBuffer/Client.UploadFile.
UploadResponse contains the response from method blockblob.Client.CommitBlockList.
UploadStreamOptions provides set of configurations for UploadStream operation
UploadStreamResponse contains the response from method Client.CommitBlockList.
RetroSearch is an open source project built by @garambo | Open a GitHub Issue
Search and Browse the WWW like it's 1997 | Search results from DuckDuckGo
HTML:
3.2
| Encoding:
UTF-8
| Version:
0.7.4