import os
import requests
url = "https://s3.amazonaws.com/my-bucket/filename.txt"
headers = {
"Authorization": os.environ.get("AWS_AUTH_HEADER"),
"Host": "s3.amazonaws.com",
"x-amz-date": os.environ.get("AWS_X_AMZ_DATE")
}
with open("filename.txt", "rb") as f:
response = requests.put(url, headers=headers, data=f)
response.raise_for_status()
import os
import httpx
url = "https://s3.amazonaws.com/my-bucket/filename.txt"
headers = {
"Authorization": os.environ.get("AWS_AUTH_HEADER"),
"Host": "s3.amazonaws.com",
"x-amz-date": os.environ.get("AWS_X_AMZ_DATE")
}
with httpx.stream("PUT", url, headers=headers, files={"file": open("filename.txt", "rb")}) as response:
response.raise_for_status()
const fs = require('fs');
const fetch = require('node-fetch');
const url = 'https://s3.amazonaws.com/my-bucket/filename.txt';
const headers = {
'Authorization': process.env.AWS_AUTH_HEADER,
'Host': 's3.amazonaws.com',
'x-amz-date': process.env.AWS_X_AMZ_DATE
};
fetch(url, {
method: 'PUT',
headers: headers,
body: fs.createReadStream('filename.txt')
}).then(response => {
if (!response.ok) throw new Error(`HTTP error! status: ${response.status}`);
});
const fs = require('fs');
const axios = require('axios');
const url = 'https://s3.amazonaws.com/my-bucket/filename.txt';
const headers = {
'Authorization': process.env.AWS_AUTH_HEADER,
'Host': 's3.amazonaws.com',
'x-amz-date': process.env.AWS_X_AMZ_DATE
};
axios.put(url, fs.createReadStream('filename.txt'), { headers })
.then(response => {
if (response.status >= 400) throw new Error(`HTTP error! status: ${response.status}`);
});
package main
import (
"log"
"net/http"
"os"
)
func main() {
url := "https://s3.amazonaws.com/my-bucket/filename.txt"
req, err := http.NewRequest("PUT", url, nil)
if err != nil {
log.Fatal(err)
}
req.Header.Set("Authorization", os.Getenv("AWS_AUTH_HEADER"))
req.Header.Set("Host", "s3.amazonaws.com")
req.Header.Set("x-amz-date", os.Getenv("AWS_X_AMZ_DATE"))
file, err := os.Open("filename.txt")
if err != nil {
log.Fatal(err)
}
defer file.Close()
req.Body = file
client := &http.Client{}
resp, err := client.Do(req)
if err != nil {
log.Fatal(err)
}
defer resp.Body.Close()
if resp.StatusCode >= 400 {
log.Fatalf("HTTP error! status: %d", resp.StatusCode)
}
}
<?php
$url = 'https://s3.amazonaws.com/my-bucket/filename.txt';
$headers = [
'Authorization: ' . getenv('AWS_AUTH_HEADER'),
'Host: s3.amazonaws.com',
'x-amz-date: ' . getenv('AWS_X_AMZ_DATE')
];
$context = stream_context_create([
'http' => [
'method' => 'PUT',
'header' => $headers,
'content' => file_get_contents('filename.txt')
]
]);
$response = file_get_contents($url, false, $context);
if ($http_response_header[0] === 'HTTP/1.1 200 OK') {
// Success
} else {
throw new Exception('HTTP error! status: ' . $http_response_header[0]);
}
?>
require 'net/http'
require 'uri'
url = URI.parse('https://s3.amazonaws.com/my-bucket/filename.txt')
req = Net::HTTP::Put.new(url.path)
req['Authorization'] = ENV['AWS_AUTH_HEADER']
req['Host'] = 's3.amazonaws.com'
req['x-amz-date'] = ENV['AWS_X_AMZ_DATE']
file = File.open('filename.txt', 'rb')
req.body_stream = file
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
response = http.request(req)
unless response.is_a?(Net::HTTPSuccess)
raise "HTTP error! status: #{response.code}"
end
import Foundation
let url = URL(string: "https://s3.amazonaws.com/my-bucket/filename.txt")!
var request = URLRequest(url: url)
request.httpMethod = "PUT"
request.setValue(ProcessInfo.processInfo.environment["AWS_AUTH_HEADER"], forHTTPHeaderField: "Authorization")
request.setValue("s3.amazonaws.com", forHTTPHeaderField: "Host")
request.setValue(ProcessInfo.processInfo.environment["AWS_X_AMZ_DATE"], forHTTPHeaderField: "x-amz-date")
let fileURL = URL(fileURLWithPath: "filename.txt")
let task = URLSession.shared.uploadTask(with: request, fromFile: fileURL) { data, response, error in
if let error = error {
fatalError(error.localizedDescription)
}
guard let httpResponse = response as? HTTPURLResponse, httpResponse.statusCode < 400 else {
fatalError("HTTP error! status: \(response?.description ?? "unknown")")
}
}
task.resume()
use std::env;
use std::fs::File;
use std::io::Read;
use reqwest::blocking::Client;
fn main() -> Result<(), Box<dyn std::error::Error>> {
let url = "https://s3.amazonaws.com/my-bucket/filename.txt";
let auth_header = env::var("AWS_AUTH_HEADER")?;
let x_amz_date = env::var("AWS_X_AMZ_DATE")?;
let mut file = File::open("filename.txt")?;
let mut buffer = Vec::new();
file.read_to_end(&mut buffer)?;
let client = Client::new();
let response = client
.put(url)
.header("Authorization", auth_header)
.header("Host", "s3.amazonaws.com")
.header("x-amz-date", x_amz_date)
.body(buffer)
.send()?;
if !response.status().is_success() {
return Err(format!("HTTP error! status: {}", response.status()).into());
}
Ok(())
}
using System;
using System.IO;
using System.Net.Http;
using System.Threading.Tasks;
class Program
{
static async Task Main()
{
var url = "https://s3.amazonaws.com/my-bucket/filename.txt";
var authHeader = Environment.GetEnvironmentVariable("AWS_AUTH_HEADER");
var xAmzDate = Environment.GetEnvironmentVariable("AWS_X_AMZ_DATE");
using var client = new HttpClient();
using var fileStream = File.OpenRead("filename.txt");
using var content = new StreamContent(fileStream);
client.DefaultRequestHeaders.Add("Authorization", authHeader);
client.DefaultRequestHeaders.Add("Host", "s3.amazonaws.com");
client.DefaultRequestHeaders.Add("x-amz-date", xAmzDate);
var response = await client.PutAsync(url, content);
if (!response.IsSuccessStatusCode)
{
throw new Exception($"HTTP error! status: {response.StatusCode}");
}
}
}