Liking cljdoc? Tell your friends :D
Clojure only.

amazonica.aws.opsworks

assign-instanceclj

(assign-instance & {:keys [instance-id layer-ids] :as assign-instance-request})

assign-volumeclj

(assign-volume & {:keys [instance-id volume-id] :as assign-volume-request})

associate-elastic-ipclj

(associate-elastic-ip &
                      {:keys [elastic-ip instance-id]
                       :as associate-elastic-ip-request})

attach-elastic-load-balancerclj

(attach-elastic-load-balancer &
                              {:keys [elastic-load-balancer-name layer-id]
                               :as attach-elastic-load-balancer-request})

client-classclj

clone-stackclj

(clone-stack &
             {:keys [agent-version attributes chef-configuration clone-app-ids
                     clone-permissions configuration-manager
                     custom-cookbooks-source custom-json
                     default-availability-zone default-instance-profile-arn
                     default-os default-root-device-type default-ssh-key-name
                     default-subnet-id hostname-theme name region
                     service-role-arn source-stack-id use-custom-cookbooks
                     use-opsworks-security-groups vpc-id]
              :as clone-stack-request})

create-appclj

(create-app &
            {:keys [app-source attributes data-sources description domains
                    enable-ssl environment name shortname ssl-configuration
                    stack-id type]
             :as create-app-request})

create-deploymentclj

(create-deployment &
                   {:keys [app-id command comment custom-json instance-ids
                           layer-ids stack-id]
                    :as create-deployment-request})

create-instanceclj

(create-instance &
                 {:keys [agent-version ami-id architecture auto-scaling-type
                         availability-zone block-device-mappings ebs-optimized
                         hostname install-updates-on-boot instance-type
                         layer-ids os root-device-type ssh-key-name stack-id
                         subnet-id tenancy virtualization-type]
                  :as create-instance-request})

create-layerclj

(create-layer &
              {:keys [attributes auto-assign-elastic-ips auto-assign-public-ips
                      cloud-watch-logs-configuration custom-instance-profile-arn
                      custom-json custom-recipes custom-security-group-ids
                      enable-auto-healing install-updates-on-boot
                      lifecycle-event-configuration name packages shortname
                      stack-id type use-ebs-optimized-instances
                      volume-configurations]
               :as create-layer-request})

create-stackclj

(create-stack &
              {:keys [agent-version attributes chef-configuration
                      configuration-manager custom-cookbooks-source custom-json
                      default-availability-zone default-instance-profile-arn
                      default-os default-root-device-type default-ssh-key-name
                      default-subnet-id hostname-theme name region
                      service-role-arn use-custom-cookbooks
                      use-opsworks-security-groups vpc-id]
               :as create-stack-request})

create-user-profileclj

(create-user-profile &
                     {:keys [allow-self-management iam-user-arn ssh-public-key
                             ssh-username]
                      :as create-user-profile-request})

delete-appclj

(delete-app & {:keys [app-id] :as delete-app-request})

delete-instanceclj

(delete-instance &
                 {:keys [delete-elastic-ip delete-volumes instance-id]
                  :as delete-instance-request})

delete-layerclj

(delete-layer & {:keys [layer-id] :as delete-layer-request})

delete-stackclj

(delete-stack & {:keys [stack-id] :as delete-stack-request})

delete-user-profileclj

(delete-user-profile & {:keys [iam-user-arn] :as delete-user-profile-request})

deregister-ecs-clusterclj

(deregister-ecs-cluster &
                        {:keys [ecs-cluster-arn]
                         :as deregister-ecs-cluster-request})

deregister-elastic-ipclj

(deregister-elastic-ip & {:keys [elastic-ip] :as deregister-elastic-ip-request})

deregister-instanceclj

(deregister-instance & {:keys [instance-id] :as deregister-instance-request})

deregister-rds-db-instanceclj

(deregister-rds-db-instance &
                            {:keys [rds-db-instance-arn]
                             :as deregister-rds-db-instance-request})

deregister-volumeclj

(deregister-volume & {:keys [volume-id] :as deregister-volume-request})

describe-agent-versionsclj

(describe-agent-versions &
                         {:keys [configuration-manager stack-id]
                          :as describe-agent-versions-request})

describe-appsclj

(describe-apps & {:keys [app-ids stack-id] :as describe-apps-request})

describe-commandsclj

(describe-commands &
                   {:keys [command-ids deployment-id instance-id]
                    :as describe-commands-request})

describe-deploymentsclj

(describe-deployments &
                      {:keys [app-id deployment-ids stack-id]
                       :as describe-deployments-request})

describe-ecs-clustersclj

(describe-ecs-clusters &
                       {:keys [ecs-cluster-arns max-results next-token stack-id]
                        :as describe-ecs-clusters-request})

describe-elastic-ipsclj

(describe-elastic-ips &
                      {:keys [instance-id ips stack-id]
                       :as describe-elastic-ips-request})

describe-elastic-load-balancersclj

(describe-elastic-load-balancers &
                                 {:keys [layer-ids stack-id]
                                  :as describe-elastic-load-balancers-request})

describe-instancesclj

(describe-instances &
                    {:keys [instance-ids layer-id stack-id]
                     :as describe-instances-request})

describe-layersclj

(describe-layers & {:keys [layer-ids stack-id] :as describe-layers-request})

describe-load-based-auto-scalingclj

(describe-load-based-auto-scaling
  &
  {:keys [layer-ids] :as describe-load-based-auto-scaling-request})

describe-my-user-profileclj

(describe-my-user-profile & {:keys [] :as describe-my-user-profile-request})

describe-operating-systemsclj

(describe-operating-systems & {:keys [] :as describe-operating-systems-request})

describe-permissionsclj

(describe-permissions &
                      {:keys [iam-user-arn stack-id]
                       :as describe-permissions-request})

describe-raid-arraysclj

(describe-raid-arrays &
                      {:keys [instance-id raid-array-ids stack-id]
                       :as describe-raid-arrays-request})

describe-rds-db-instancesclj

(describe-rds-db-instances &
                           {:keys [rds-db-instance-arns stack-id]
                            :as describe-rds-db-instances-request})

describe-service-errorsclj

(describe-service-errors &
                         {:keys [instance-id service-error-ids stack-id]
                          :as describe-service-errors-request})

describe-stack-provisioning-parametersclj

(describe-stack-provisioning-parameters
  &
  {:keys [stack-id] :as describe-stack-provisioning-parameters-request})

describe-stack-summaryclj

(describe-stack-summary & {:keys [stack-id] :as describe-stack-summary-request})

describe-stacksclj

(describe-stacks & {:keys [stack-ids] :as describe-stacks-request})

describe-time-based-auto-scalingclj

(describe-time-based-auto-scaling
  &
  {:keys [instance-ids] :as describe-time-based-auto-scaling-request})

describe-user-profilesclj

(describe-user-profiles &
                        {:keys [iam-user-arns]
                         :as describe-user-profiles-request})

describe-volumesclj

(describe-volumes &
                  {:keys [instance-id raid-array-id stack-id volume-ids]
                   :as describe-volumes-request})

detach-elastic-load-balancerclj

(detach-elastic-load-balancer &
                              {:keys [elastic-load-balancer-name layer-id]
                               :as detach-elastic-load-balancer-request})

disassociate-elastic-ipclj

(disassociate-elastic-ip &
                         {:keys [elastic-ip]
                          :as disassociate-elastic-ip-request})

get-cached-response-metadataclj

(get-cached-response-metadata & [amazon-web-service-request])

get-hostname-suggestionclj

(get-hostname-suggestion &
                         {:keys [layer-id] :as get-hostname-suggestion-request})

grant-accessclj

(grant-access &
              {:keys [instance-id valid-for-in-minutes]
               :as grant-access-request})

list-tagsclj

(list-tags &
           {:keys [max-results next-token resource-arn] :as list-tags-request})

reboot-instanceclj

(reboot-instance & {:keys [instance-id] :as reboot-instance-request})

register-ecs-clusterclj

(register-ecs-cluster &
                      {:keys [ecs-cluster-arn stack-id]
                       :as register-ecs-cluster-request})

register-elastic-ipclj

(register-elastic-ip &
                     {:keys [elastic-ip stack-id]
                      :as register-elastic-ip-request})

register-instanceclj

(register-instance &
                   {:keys [hostname instance-identity private-ip public-ip
                           rsa-public-key rsa-public-key-fingerprint stack-id]
                    :as register-instance-request})

register-rds-db-instanceclj

(register-rds-db-instance &
                          {:keys [db-password db-user rds-db-instance-arn
                                  stack-id]
                           :as register-rds-db-instance-request})

register-volumeclj

(register-volume & {:keys [ec2-volume-id stack-id] :as register-volume-request})

set-load-based-auto-scalingclj

(set-load-based-auto-scaling &
                             {:keys [down-scaling enable layer-id up-scaling]
                              :as set-load-based-auto-scaling-request})

set-permissionclj

(set-permission &
                {:keys [allow-ssh allow-sudo iam-user-arn level stack-id]
                 :as set-permission-request})

set-time-based-auto-scalingclj

(set-time-based-auto-scaling &
                             {:keys [auto-scaling-schedule instance-id]
                              :as set-time-based-auto-scaling-request})

show-functionsclj

shutdownclj

(shutdown)

start-instanceclj

(start-instance & {:keys [instance-id] :as start-instance-request})

start-stackclj

(start-stack & {:keys [stack-id] :as start-stack-request})

stop-instanceclj

(stop-instance & {:keys [force instance-id] :as stop-instance-request})

stop-stackclj

(stop-stack & {:keys [stack-id] :as stop-stack-request})

tag-resourceclj

(tag-resource & {:keys [resource-arn tags] :as tag-resource-request})

unassign-instanceclj

(unassign-instance & {:keys [instance-id] :as unassign-instance-request})

unassign-volumeclj

(unassign-volume & {:keys [volume-id] :as unassign-volume-request})

untag-resourceclj

(untag-resource & {:keys [resource-arn tag-keys] :as untag-resource-request})

update-appclj

(update-app &
            {:keys [app-id app-source attributes data-sources description
                    domains enable-ssl environment name ssl-configuration type]
             :as update-app-request})

update-elastic-ipclj

(update-elastic-ip & {:keys [elastic-ip name] :as update-elastic-ip-request})

update-instanceclj

(update-instance &
                 {:keys [agent-version ami-id architecture auto-scaling-type
                         ebs-optimized hostname install-updates-on-boot
                         instance-id instance-type layer-ids os ssh-key-name]
                  :as update-instance-request})

update-layerclj

(update-layer &
              {:keys [attributes auto-assign-elastic-ips auto-assign-public-ips
                      cloud-watch-logs-configuration custom-instance-profile-arn
                      custom-json custom-recipes custom-security-group-ids
                      enable-auto-healing install-updates-on-boot layer-id
                      lifecycle-event-configuration name packages shortname
                      use-ebs-optimized-instances volume-configurations]
               :as update-layer-request})

update-my-user-profileclj

(update-my-user-profile &
                        {:keys [ssh-public-key]
                         :as update-my-user-profile-request})

update-rds-db-instanceclj

(update-rds-db-instance &
                        {:keys [db-password db-user rds-db-instance-arn]
                         :as update-rds-db-instance-request})

update-stackclj

(update-stack &
              {:keys [agent-version attributes chef-configuration
                      configuration-manager custom-cookbooks-source custom-json
                      default-availability-zone default-instance-profile-arn
                      default-os default-root-device-type default-ssh-key-name
                      default-subnet-id hostname-theme name service-role-arn
                      stack-id use-custom-cookbooks
                      use-opsworks-security-groups]
               :as update-stack-request})

update-user-profileclj

(update-user-profile &
                     {:keys [allow-self-management iam-user-arn ssh-public-key
                             ssh-username]
                      :as update-user-profile-request})

update-volumeclj

(update-volume & {:keys [mount-point name volume-id] :as update-volume-request})

waitersclj

(waiters)

cljdoc is a website building & hosting documentation for Clojure/Script libraries

Keyboard shortcutsReport a problemcljdoc on GitHub
× close