additional_secret_outputs=['result'])).result,
end_date_relative='8760h',
)
sp_auth = azure.authorization.Assignment(
'myauth',
scope=registry.id,
role_definition_name='acrpush',
principal_id=sp.id,
)
registry_info = docker.ImageRegistry(
server=registry.login_server,
username=sp.application_id,
password=sp_auth.id.apply(lambda _: sp_password.value),
)
else:
registry_info = docker.ImageRegistry(server=registry.login_server,
username=registry.admin_username,
password=registry.admin_password)
# Build and publish the image.
image = docker.Image(
'my-image',
build='app',
image_name=image_name,
registry=registry_info,
)
# Export the resulting base name in addition to the specific version pushed.
pulumi.export('baseImageName', image.base_image_name)
pulumi.export('imageName', image.image_name)
registry = containerregistry.Registry("registry",
resource_group_name=resource_group.name,
sku=containerregistry.SkuArgs(name="Basic"),
admin_user_enabled=True)
credentials = pulumi.Output.all(resource_group.name, registry.name).apply(
lambda args: containerregistry.list_registry_credentials(resource_group_name=args[0],
registry_name=args[1]))
admin_username = credentials.username
admin_password = credentials.passwords[0]["value"]
custom_image = "node-app"
my_image = docker.Image(custom_image,
image_name=registry.login_server.apply(
lambda login_server: f"{login_server}/{custom_image}:v1.0.0"),
build=docker.DockerBuild(context=f"./{custom_image}"),
registry=docker.ImageRegistry(
server=registry.login_server,
username=admin_username,
password=admin_password))
container_app = web.ContainerApp("app",
resource_group_name=resource_group.name,
kube_environment_id=kube_env.id,
configuration=web.ConfigurationArgs(
ingress=web.IngressArgs(
external=True,
target_port=80
),
registries=[
web.RegistryCredentialsArgs(
server=registry.login_server,
import base64
import pulumi
import pulumi_aws as aws
import pulumi_docker as docker
from pulumi_aws import ecr
def get_registry_info(rid):
creds = aws.ecr.get_credentials(rid)
decoded = base64.b64decode(creds.authorization_token).decode()
parts = decoded.split(':')
if len(parts) != 2:
raise Exception("Invalid credentials")
return docker.ImageRegistry(creds.proxy_endpoint, parts[0], parts[1])
repository = ecr.Repository("test-repository", name="test-repository")
registry = repository.registry_id.apply(get_registry_info)
image = docker.Image(
'my-image',
build=docker.DockerBuild(context='.', args={}),
image_name=repository.repository_url.apply(lambda url: url + ':latest'),
registry=registry)
# Creating a Docker image from "./frontend/Dockerfile", which we will use
# to upload our app
def get_registry_info(rid):
creds = aws.ecr.get_credentials(registry_id=rid)
decoded = base64.b64decode(creds.authorization_token).decode()
parts = decoded.split(':')
if len(parts) != 2:
raise Exception("Invalid credentials")
return docker.ImageRegistry(creds.proxy_endpoint, parts[0], parts[1])
app_registry = app_ecr_repo.registry_id.apply(get_registry_info)
flask_image = docker.Image("flask-dockerimage",
image_name=app_ecr_repo.repository_url,
build="./frontend",
skip_push=False,
registry=app_registry)
# Creating a task definition for the Flask instance.
flask_task_definition = aws.ecs.TaskDefinition(
"flask-task-definition",
family="frontend-task-definition-family",
cpu="256",
memory="512",
network_mode="awsvpc",
requires_compatibilities=["FARGATE"],
execution_role_arn=app_exec_role.arn,
task_role_arn=app_task_role.arn,
container_definitions=pulumi.Output.all(flask_image.image_name,
redis_endpoint).
raise Exception("Invalid credentials")
return docker.ImageRegistry(creds.proxy_endpoint, parts[0], parts[1])
# Create a private ECR registry.
repo = aws.ecr.Repository(image_name, name=image_name)
registry = repo.registry_id.apply(get_registry_info)
image_tag = repo.repository_url.apply(lambda url: url + ":latest")
# Build and publish the image.
build_image = docker.Image(
image_name,
build=docker.DockerBuild(context='app'),
image_name=image_tag,
registry=registry,
# opts=ResourceOptions(aliases="hw_image")
)
# Deployment based on simpledeployment
helloworldapp = SimpleDeployment(
"helloworld",
replicas=2,
image=image_tag,
ports=[80],
envvars=[{
"name": "MESSAGE",
"value": message
}],
opts=ResourceOptions(depends_on=[build_image]))
import pulumi
import pulumi_docker as docker
from pulumi_kubernetes.apps.v1 import Deployment
from pulumi_kubernetes.core.v1 import Secret, Service
# Fetch the Docker Hub auth info from config.
config = pulumi.Config()
username = config.require('dockerUsername')
password = config.require_secret('dockerPassword')
# Build and publish the image.
image = docker.Image('my-image',
build='app',
image_name=f'{username}/myapp',
registry=password.apply(lambda pwd: docker.ImageRegistry(
server='docker.io',
username=username,
password=pwd,
)),
)
# Ensure we can pull from the Docker Hub.
pull_secret = Secret('my-regcred',
type='kubernetes.io/dockerconfigjson',
string_data={
'.dockerconfigjson': password.apply(lambda pwd: json.dumps({
'auths': {
'https://index.docker.io/v1/': {
'username': username,
'password': pwd,
'auth': str(base64.b64encode(f'{username}:{pwd}'.encode('utf-8')), 'utf-8'),
import pulumi_aws as aws
import pulumi_docker as docker
# Create a private ECR registry.
repo = aws.ecr.Repository('my-repo')
# Get registry info (creds and endpoint) so we can build/publish to it.
def getRegistryInfo(rid):
creds = aws.ecr.get_credentials(registry_id=rid)
decoded = base64.b64decode(creds.authorization_token).decode()
parts = decoded.split(':')
if len(parts) != 2:
raise Exception("Invalid credentials")
return docker.ImageRegistry(creds.proxy_endpoint, parts[0], parts[1])
registry = repo.registry_id.apply(getRegistryInfo)
# Build and publish the image.
image = docker.Image(
'my-image',
build='app',
image_name=repo.repository_url,
registry=registry,
)
# Export the resulting base name in addition to the specific version pushed.
pulumi.export('baseImageName', image.base_image_name)
pulumi.export('imageName', image.image_name)
import base64
from pulumi_aws import ecr
import pulumi_docker as docker
import pulumi
app = 'my-app'
# Create repository
repo = ecr.Repository(app)
def create_image_registry(rid):
creds = ecr.get_credentials(rid)
decoded = base64.b64decode(creds.authorization_token).decode('utf-8')
username, password = decoded.split(':')
return docker.ImageRegistry(creds.proxy_endpoint, username, password)
# Get credentials and create an ImageRegistry from that
registry = repo.registry_id.apply(lambda rid: create_image_registry(rid))
# Create image
image = docker.Image(app,
image_name=pulumi.Output.concat(repo.repository_url, ':',
'1.0.0'),
build=docker.DockerBuild(context=f'./{app}'),
registry=registry)
import pulumi
import pulumi_docker as docker
import pulumi_github as github
env = pulumi.get_stack()
my_image = docker.Image(
name="my-nginx",
image_name="pulumi-demo:0.0.1",
build=docker.DockerBuild(
dockerfile="Dockerfile"
),
skip_push=True,
)
# pulumi.export('IMAGE', my_image)
# image_to_use = docker.RemoteImage("my-nginx",
# name="pulumi-demo:0.0.1",
# keep_locally=True
# )
container = docker.Container("my-nginx",
name="my-nginx",
image=my_image.base_image_name,
ports=[{"internal":80, "external":80}]
)
# pulumi.export('CONTAINER', container)
repo = pulumi.StackReference('aldenso/github_example/'+env)
import base64
import pulumi_aws as aws
import pulumi_docker as docker
import pulumi
# Get registry info (creds and endpoint) so we can build/publish to it.
def get_registry_info(rid):
creds = aws.ecr.get_credentials(registry_id=rid)
decoded = base64.b64decode(creds.authorization_token).decode()
parts = decoded.split(':')
if len(parts) != 2:
raise Exception("Invalid credentials")
return docker.ImageRegistry(creds.proxy_endpoint, parts[0], parts[1])
for i in range(3):
# Create a private ECR registry.
repo = aws.ecr.Repository('my-repo-%i' % i)
registry = repo.registry_id.apply(get_registry_info)
# Build and publish the image.
docker.Image(
'my-image-%i' % i,
build=docker.DockerBuild(context='app', args={'parameter': str(i)}),
image_name=repo.repository_url,
registry=registry,
)
redis_image = docker.RemoteImage("redis_image",
name="redis:6.2",
keep_locally=True)
redis_container = docker.Container(
"redis_container",
image=redis_image.latest,
ports=[docker.ContainerPortArgs(internal=redis_port, external=redis_port)],
networks_advanced=[
docker.ContainerNetworksAdvancedArgs(name=network.name,
aliases=[redis_host])
])
app_image = docker.Image("app_image",
build=docker.DockerBuild(context="./app"),
image_name="app",
skip_push=True)
app_port = 5000
app_container = docker.Container(
"app_container",
image=app_image.base_image_name,
ports=[docker.ContainerPortArgs(internal=app_port, external=app_port)],
envs=[f"REDIS_HOST={redis_host}", f"REDIS_PORT={redis_port}"],
networks_advanced=[
docker.ContainerNetworksAdvancedArgs(name=network.name)
],
opts=pulumi.ResourceOptions(depends_on=[redis_container]))
pulumi.export("url", f"http://localhost:{app_port}")
import pulumi
import pulumi_aws as aws
import pulumi_docker as docker
bucket = aws.s3.Bucket("bucket")
repo = aws.ecr.Repository("sampleapp")
ecr_creds = aws.ecr.get_authorization_token()
image = docker.Image("sampleapp",
build="./build-ffmpeg",
image_name=repo.repository_url,
registry=docker.ImageRegistry(
server=repo.repository_url,
username=ecr_creds.user_name,
password=ecr_creds.password))
role = aws.iam.Role("thumbnailerRole",
assume_role_policy=f"""{{
"Version": "2012-10-17",
"Statement": [
{{
"Effect": "Allow",
"Principal": {{ "Service": "lambda.amazonaws.com" }},
"Action": "sts:AssumeRole"
}}
]
}}""")
aws.iam.RolePolicyAttachment(
"lambdaFullAccess",
"""An Azure Python Pulumi program"""
import pulumi
from pulumi_azure import core, containerservice
import pulumi_docker
# Create an Azure Resource Group
resource_group = core.ResourceGroup('miw_20200729')
# Create registry
registry = containerservice.Registry('registry',
admin_enabled=True,
sku='Basic',
resource_group_name=resource_group.name)
# ImageRegistry
r = pulumi.Output.all(
registry.login_server, registry.admin_username,
registry.admin_password).apply(
lambda a: pulumi_docker.ImageRegistry(a[0], a[1], a[2]))
# Build and publish image
image = pulumi_docker.Image(
"my-app",
image_name=registry.login_server.apply(lambda s: f'{s}/my-app:v1.0.0'),
build=pulumi_docker.DockerBuild(context='./my-app'),
registry=r)
