amazon web services - Cómo publicar en Amazon S3 con sbt

amazon-web-services amazon-s3

Question

Como se explica aquí , se puede implementar en Amazon S3 con maven.

¿Cómo podemos hacer lo mismo con sbt, es decir, publicar en S3 con sbt?

Answer 1

No he intentado esto, pero al mirar los documentos api, esto podría funcionar:

1. Obtenga 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 (ver http://repo1.maven.org/maven2/org/springframework/aws/spring-aws-ivy/1.0/ --- debería poder descargar el jar en project/lib/ , o poner "org.springframework.aws" % "spring-aws-ivy" % "1.0" en project/build.sbt ).

2. Agregue esto a su build.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)
   }

De nuevo, no he intentado esto, pero dado que publishTo es un SettingKey[Option[Resolver]] , y RawRepository extiende Resolver y toma un org.apache.ivy.plugins.resolver.DependencyResolver , y S3Resolver implementa DependencyResolver , supongo que funcionaría.

Después de todo, sbt es solo un envoltorio alrededor de Apache Ivy.

Answer 2

Pude hacer que esto funcionara con el plugin sbt-s3

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

Aquí hay un ejemplo:

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")))
}

Answer 3

La pregunta es bastante antigua, por lo que puede ser que ya hayas encontrado alguna solución, pero puede ser que esta respuesta sea útil para otra persona.

También tuvimos ese problema en nuestro equipo y acabamos de crear un sbt-plugin para eso: sbt-s3-resolver . Estuvimos usándolo por un tiempo y parece que funciona bien. Puede

• publicar artefactos de hiedra / maven en cubos S3 (privados / públicos)
• resuelve artefactos de hiedra de cubos privados (porque desde cubos públicos puedes resolver con resolvedores de sbt estándar)

Eche un vistazo a las instrucciones de uso en el archivo léame y abra un problema si falta algo.

Answer 4

He usado los dos complementos ya mencionados ( https://github.com/ohnosequences/sbt-s3-resolver y https://github.com/frugalmechanic/fm-sbt-s3-resolver ), pero terminé escribiendo el mío :

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

Aquí hay una muestra de características que son únicas y / o ya se mencionaron en otras respuestas:

• Publique una lista de directorios de estilo Apache si desea que los artefactos estén disponibles públicamente mediante la característica de alojamiento de sitios web de S3.
• Se predetermina a DefaultAWSCredentialsProviderChain , pero expone una configuración si desea configurar su propio proveedor
• Publicar en una ruta en un cubo (por ejemplo, s3: //munchii.com/snapshots)
• Admite revisiones dinámicas (p. Ej., 1.0. +)
• Licenciado con Apache 2.0

Answer 5

Yo también tuve que cargar un contenedor jar a s3 bucket desde nuestra herramienta de compilación. @dres respuesta me ayudó a ir en la dirección correcta.

Lo tengo trabajando con lo siguiente en el archivo build.sbt .

Como puede ver, aquí he utilizado los SettingKey[String] de SettingKey[String] disponibles en sbt-assembly

// 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 le brinda la ruta de salida completa de su archivo jar de ensamblaje
• assemblyJarName in assembly le proporciona el nombre de jar producido por el ensamblado.
• necesita invocar .value para obtener el valor real de las claves SBT

Esto carga el archivo ensamblador a my-bucket bajo name/version/name-assembly-version.jar , con el comando sbt s3Upload .

Tenga en cuenta que también configuré AWS_ACCESS_KEY_ID y AWS_SECRET_ACCESS_KEY en el entorno. El orden en que se buscan las credenciales se puede encontrar aquí .

Answer 6

Aquí hay un plugin de SBT que escribí para publicar en Amazon S3: https://github.com/frugalmechanic/fm-sbt-s3-resolver

Es similar al ya mencionado sbt-s3-resolver, pero está Apache 2.0 Licensed (en lugar de AGPL) y está disponible en Maven Central. También es un poco más fácil de usar y configurar.

Publicando en S3

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

Resolviendo desde S3

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

Habilitar el complemento

Solo agregue esto a su archivo de proyecto / plugins.sbt:

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

Configurar las credenciales de AWS

Hay varias formas de configurar las credenciales de AWS que están documentadas en la página de GitHub .

Un método es crear un ~ / .sbt / .s3credentials que se ve así:

accessKey = XXXXXXXXXX
secretKey = XXXXXXXXXX

El complemento seleccionará automáticamente el archivo de credenciales y podrá resolverlo y publicarlo.