Comment publier sur Amazon S3 avec sbt

voici un Plugin SBT que j'ai écrit pour Amazon S3:https://github.com/frugalmechanic/fm-sbt-s3-resolver

c'est similaire à ce qui a déjà été mentionné sbt-S3-resolver mais est sous licence Apache 2.0 (au lieu de AGPL) et est disponible sur Maven Central. Il est également un peu plus facile à utiliser et configurer.

Publication de S3

publishTo := Some("S3" at "s3://s3-us-west-2.amazonaws.com/YOUR_BUCKET/repo")

Résolution de S3

resolvers += "S3" at "s3://s3-us-west-2.amazonaws.com/YOUR_BUCKET/repo"

Activer l' Plugin

il suffit d'ajouter ceci à votre projet/plugins.fichier sbt:

addSbtPlugin("com.frugalmechanic" % "fm-sbt-s3-resolver" % "0.16.0")

configurer les justificatifs AWS

il y a plusieurs façons de configurer les identifiants AWS qui sont documentés sur le GitHub.

une méthode est de créer un ~/.sbt/.s3credentials qui ressemble à:

accessKey = XXXXXXXXXX
secretKey = XXXXXXXXXX

le fichier d'authentification sera automatiquement récupéré par le plugin et vous pourrez le résoudre et le publier.

la question est assez ancienne, donc peut-être que vous avez déjà trouvé une solution, mais peut-être que cette réponse sera utile pour quelqu'un d'autre.

Nous avons aussi eu ce genre de problème dans notre équipe et nous venons de créer un sbt-plugin pour ça: sbt-S3-resolver. Nous avons été utilisé pendant un certain temps et il semble faire du bon travail. Il peut

• publier des artéfacts ivy / maven dans des seaux S3 (privés / publics)
• résoudre ivy artefacts de privé seaux (parce que des seaux publics vous pouvez résoudre avec des résolveurs sbt standard)

consultez les instructions d'utilisation dans readme et ouvrir un problème si quelque chose manque.

j'ai été capable de faire fonctionner cela en utilisant le plugin sbt-s3

https://github.com/sbt/sbt-s3

Voici un exemple:

import sbt._
import Keys._
import play.Project._

import com.typesafe.sbt.S3Plugin._
import S3._
import sbtassembly.Plugin.AssemblyKeys
import sbtassembly.Plugin.AssemblyKeys._
import sbtassembly.Plugin.assemblySettings
import sbtassembly.Plugin.MergeStrategy
import sbtbuildinfo.Plugin._

object ApplicationBuild extends Build {

  val appName = "og-ws"
  val appVersion = "1.0-SNAPSHOT"

  val appDependencies = Seq(
    // Add your project dependencies here,
    jdbc,
    anorm,
    "com.netflix.astyanax" % "astyanax-cassandra" % "1.56.28",
    "com.netflix.astyanax" % "astyanax-thrift" % "1.56.28",
    "com.netflix.astyanax" % "astyanax-entity-mapper" % "1.56.28")

  val main = (
    play.Project(appName, appVersion, appDependencies)
    settings (s3Settings: _*)
    settings (assemblySettings: _*)
    settings (
      // call its setters to configure it, see api docs above etc.
      publish := (),
      publishLocal := (),
      mappings in upload <<= dist map { distFile =>
        Seq(distFile -> "snapshot/%s/%s/%s-%s.zip".format(appName, appVersion, appName, appVersion))
      },
      host in upload := "plaor.maven.s3.amazonaws.com",
      credentials += Credentials(Path.userHome / ".s3credentials")))
}

je n'ai pas essayé, mais en regardant les docs de l'api, cela peut fonctionner:

1. Obtenir http://www.jarvana.com/jarvana/view/org/springframework/aws/spring-aws-ivy/1.0/spring-aws-ivy-1.0-javadoc.jar!/org/springframework/aws/ivy/S3Resolver.html (voir http://repo1.maven.org/maven2/org/springframework/aws/spring-aws-ivy/1.0/ --- vous devriez être en mesure de télécharger le jar project/lib/, ou de mettre des "org.springframework.aws" % "spring-aws-ivy" % "1.0" dans project/build.sbt).

2. Ajouter ceci à votre construction.sbt:

   {
     val s3r = new org.springframework.aws.ivy.S3Resolver
     // call its setters to configure it, see api docs above etc.
     publishTo := Some(new sbt.RawRepository(s3r)
   }
   

Encore une fois, je n'ai pas essayé, mais depuis publishTo est un SettingKey[Option[Resolver]] et RawRepository extends Resolver et prend un org.apache.ivy.plugins.resolver.DependencyResolver et S3Resolver implémente DependencyResolver, je suppose que ça marcherait.

après tout, sbt n'est vraiment qu'une couverture autour D'Apache Ivy.

moi aussi j'ai dû télécharger un pot d'assemblage sur S3 bucket à partir de notre outil de construction. @dres réponse m'a aidé à aller dans la bonne direction.

je l'ai eu à travailler avec la suite build.sbt fichier.

Comme vous pouvez le voir, ici, j'ai fait de l'utilisation de SettingKey[String] valeurs disponibles dans sbt-assemblée

// s3Upload
import S3._

s3Settings
mappings in upload := Seq(
  (assemblyOutputPath in assembly).value -> 
       s"${name.value}/${version.value}/${(assemblyJarName in assembly).value}"
)

host in upload := "my-bucket.s3.amazonaws.com"

S3.progress in S3.upload := true

• assemblyOutputPath in assembly vous donne le chemin de sortie complet de votre fichier JAR d'assemblage
• assemblyJarName in assembly vous donne le nom du pot produit par Assemblée.
• vous avez besoin d'invoquer .value pour obtenir la valeur réelle de SBT touches

cette version télécharge le pot d'assemblage vers my-bucketname/version/name-assembly-version.jar avec la commande sbt s3Upload.

Notez que, j'ai aussi mis mon AWS_ACCESS_KEY_ID et AWS_SECRET_ACCESS_KEY dans l'environnement. L'ordre dans lequel les références sont recherchées peut être trouvé ici.

j'ai utilisé les deux plugins déjà mentionnés (https://github.com/ohnosequences/sbt-s3-resolver et https://github.com/frugalmechanic/fm-sbt-s3-resolver), mais a fini par écrire le mien:

https://github.com/munchii/sbt-s3-resolver

Voici un échantillon des caractéristiques qui sont uniques et/ou déjà mentionné par d'autres réponses:

• Publier Apache liste de répertoires, si vous voulez faire artéfacts accessibles au public grâce à la fonction d'hébergement du site web de S3
• par défaut à DefaultAWSCredentialsProviderChain, mais présente un paramètre si vous souhaitez configurer votre propre fournisseur
• Publier sur un chemin dans un seau (par exemple, s3://munchii.com/captures d'écran)
• dynamique des révisions (par exemple, 1.0.+)
• sous Licence Apache 2.0