Cmo Implementar un WorkManager Distribuido de CommonJ

En este artculo te mostrar como implementar una versin distribuida de la especificacin CommonJ WorkManager usando Terracotta para Spring. Este artculo es una variacin de un artculo escrito por TheServerSide.com titulado Distributed Computing Made Easy, un artculo que puede ser encontrado Aqu.

Qu es WorkManager CommonJ?
CommonJ es una especificacin conjunta de BEA y IBM que proporciona un estndar para ejecutar tareas concurrentes en un entorno JEE. Por ejemplo tiene soporte para el patrn Master/Worker en su API WorkManager. De la documentacin de BEA sobre la especificacin: El Work Manager proporciona una API simple para ejecucin concurrente de elementos de trabajo soportada por el servidor de la aplicacin. This enables J2EE-based applications (including Servlets and EJBs) to schedule work items for concurrent execution, which will provide greater throughput and increased response time. After an application submits work items to a Work Manager for concurrent execution, the application can gather the results. The Work Manager provides common join operations, such as waiting for any or all work items to complete. The Work Manager for Application Servers specification provides an application-server-supported alternative to using lower-level threading APIs, which are inappropriate for use in managed environments such as Servlets and EJBs, as well as being too difficult to use for most applications." What we are going to do is to first implement a the specification as a regular single node multi-threaded application, based on the Master/Worker pattern. We are also going to use the Spring Framework and implement the Master, Worker and Shared Queue entities as three different Spring beans; MyWorkManager, Worker and WorkQueue. We will then use Terracotta for Spring* to transparently and declaratively, turn this implementation into a multi-node, distributed WorkManager.

Master (WorkManager)
MyWorkManager

bean implements the CommonJ WorkManager interface which has the API that the user uses to schedule Work and wait for all Work to be completed. The MyWorkManager bean does not have any state, and can therefore be configured as a Prototype in the Spring bean config XML file. Here is how we could implement the work manager bean:
public class MyWorkManager implements WorkManager { // The Work Queue bean, is injected by Spring private final WorkQueue m_queue; public MyWorkManager(WorkQueue queue) {

m_queue = queue; } public WorkItem schedule(final Work work) throws WorkException { WorkItem workItem = new MyWorkItem(work, null); m_queue.addWork(workItem); return workItem; } public WorkItem schedule(Work work, WorkListener listener) hrows WorkException { WorkItem workItem = new MyWorkItem(work, listener); m_queue.addWork(workItem); // adds work to the shared queue return workItem; } public boolean waitForAll(Collection workItems, long timeout) { long start = System.currentTimeMillis(); do { boolean isAllCompleted = true; for (Iterator it = workItems.iterator(); it.hasNext() && isAllCompleted;) { int status = ((WorkItem) it.next()).getStatus(); isAllCompleted = status == WorkEvent.WORK_COMPLETED || status == WorkEvent.WORK_REJECTED; } if (isAllCompleted) { return true; } if (timeout == IMMEDIATE) { return false; } if (timeout == INDEFINITE) { continue; } } while ((System.currentTimeMillis() - start) < timeout); return false; } public Collection waitForAny(Collection workItems, long timeout) { long start = System.currentTimeMillis(); do { synchronized (this) { Collection completed = new ArrayList(); for (Iterator it = workItems.iterator(); it.hasNext();) { WorkItem workItem = (WorkItem) it.next(); if (workItem.getStatus() == WorkEvent.WORK_COMPLETED || workItem.getStatus() == WorkEvent.WORK_REJECTED) { completed.add(workItem); } } if (!completed.isEmpty()) { return completed; } } if (timeout == IMMEDIATE) { return Collections.EMPTY_LIST; } if (timeout == INDEFINITE) { continue; } } while ((System.currentTimeMillis() - start) < timeout); return Collections.EMPTY_LIST;

} }

Shared Queue
The MyWorkManager bean schedules work by adding work to the WorkQueue bean, which is a simple wrapper around a java.util.concurrent.BlockingQueue queue. The WorkQueue bean is the bean that has state, since it holds the queue with all the pending Work. We need to have a single instance of this queue that can be available to all workers, and we therefore define it as Singleton in the bean config XML file. The work queue can be implemented like this:
<BR> public class WorkQueue {<BR> private final BlockingQueue m_workQueue;<P></P> public WorkQueue() { m_workQueue = new LinkedBlockingQueue(); } public WorkQueue(int capacity) { m_workQueue = new LinkedBlockingQueue(capacity); } public MyWorkItem getWork() throws WorkException { try { return (MyWorkItem) m_workQueue.take(); // blocks if empty } catch (InterruptedException e) { throw new WorkException(e); } } public void addWork(WorkItem workItem) throws WorkException { try { m_workQueue.put(workItem); } catch (InterruptedException e) { WorkRejectedException we = new WorkRejectedException(e.getMessage()); ((MyWorkItem)workItem).setStatus(WorkEvent.WORK_REJECTED, we); throw we; } } <P>}<BR> </P>

Worker
Finally, we have the Worker bean. This bean uses a thread pool to spawn up N number of worker threads that continuously grabs and executes Work from the WorkQueue. During the processing of the Work, its status flag is maintained (can be one of either Accepted, Started, Completed or Rejected), this is needed in order for the MyWorkManager bean to be able to continuously monitor the status of the Work it has scheduled. The Worker bean does not have any shared state and is configured as a Prototype in the bean config XML file.

This is what a worker bean implementation can look like. As you can see we choose to make use of the Executor thread pool implementation in the java.util.concurrent package:
public class Worker { private transient final WorkQueue m_queue; private transient final ExecutorService m_threadPool = Executors.newCachedThreadPool(); private volatile boolean m_isRunning = true; public Worker(WorkQueue queue) { m_queue = queue; } public void start() throws WorkException { while (m_isRunning) { final MyWorkItem workItem = m_queue.getWork(); m_threadPool.execute(new Runnable() { public void run() { try { Work work = workItem.getResult(); workItem.setStatus(WorkEvent.WORK_STARTED, null); work.run(); workItem.setStatus(WorkEvent.WORK_COMPLETED, null); } catch (Throwable e) { workItem.setStatus(WorkEvent.WORK_REJECTED, new WorkRejectedException(e.getMessage())); } }); } } } }

Assembly
These three beans can now be wired up by the Spring bean config file:
&lt;beans&gt; &lt;!-- workManager is prototype - not shared --&gt; &lt;bean id="workManager" class="com.jonasboner.commonj.workmanager.MyWorkManager" singleton="false"&gt; &lt;constructor-arg ref="queue"/&gt; &lt;/bean&gt; &lt;!-- worker is prototype - not shared --&gt; &lt;bean id="worker" class="com.jonasboner.commonj.workmanager.Worker" singleton="false"&gt; &lt;constructor-arg ref="queue"/&gt; &lt;/bean&gt; &lt;!-- the work queue is singleton - can be made shared by Terracotta --&gt; &lt;bean id="queue" class="com.jonasboner.commonj.workmanager.WorkQueue"/&gt; &lt;/beans&gt;

We now have a fully functional local, multi-threaded, implementation of the CommonJ WorkManager specification.

Making the WorkManager distributed

Now comes the hard part right? Wellno. It turns out that in order to turn this implementation into a distributed WorkManager, all we have to do is to create a Terracotta configuration file in which we declare the Spring beans that we want to share across the cluster: ... &lt;spring&gt; &lt;jee-application name="webAppName"&gt; &lt;application-contexts&gt; &lt;application-context&gt; &lt;paths&gt; &lt;path&gt;*/work-manager.xml&lt;/path&gt; &lt;/paths&gt; &lt;beans&gt; &lt;bean name="queue"/&gt; &lt;/beans&gt; &lt;/application-context&gt; &lt;/application-contexts&gt; &lt;/jee-application&gt; &lt;/spring&gt; ... Done! Now we have a fully distributed, multi-JVM CommonJ WorkManager.

Client usage
Using the distributed work manager is now simply a matter of getting the bean from the application context and invoke schedule(..):
ApplicationContext ctx = new ClassPathXmlApplicationContext("*/work-manager.xml"); // get the work manager from the application context WorkManager workManager = (WorkManager) ctx.getBean("workManager"); Set pendingWork = new HashSet(); for (int i = 0; i < nrOfWork; i++) { // schedule work WorkItem workItem = workManager.schedule(new Work() { public void run() { ... // do work } }); // collect the pending work

pendingWork.add(workItem); } // wait for all work to be completed workManager.waitForAll(pendingWork, WorkManager.INDEFINITE);

To start up a Worker you simply have to get the Worker bean from the application context and invoke start():
<BR> ApplicationContext ctx = <BR> new ClassPathXmlApplicationContext(*/work-manager.xml);<P></P> <P>// get the worker from the application context<BR> Worker worker = (Worker) ctx.getBean(worker);</P> <P>// starting worker<BR> worker.start();<BR> </P>

The usage of the distributed version would roughly be to start up one WorkManager bean and N number of Worker beans, each one on a different JVM. That is all there is to it. Now we have a simple, distributed, reliable, high-performant and scalable CommonJ WorkManager ready for use. Enjoy.

RC 1 of Terracotta for Spring was released some days ago (9/12/2006) and is free for production use for up to two nodes.

Reactions

Java Champion Subscribe: Atom Feed Email: jonas@jonasboner.com Work: scalablesolutions.se Product: akka.io Hacking: github.com/jboner Tweeting: twitter.com/jboner

Upcoming Talks

2.09.11: Reaktor conference - Helsinki, Finland 29.09.11: GOTO - Amsterdam, Netherlands 17.11.11: Devoxx - Antwerp, Belgium 1.12.11: YOW! - Melbourne, Australia 5.12.11: YOW! - Brisbane, Australia

Gestores de trabajo
Un gestor de trabajo es una agrupacin de hebras creada para las aplicaciones J2EE que utilizan beans asncronos. Con la consola administrativa, el administrador puede configurar el nmero que desee de gestores de trabajos. El administrador especifica las propiedades del gestor de trabajos, incluida la poltica de herencia de contexto J2EE de los beans asncronos que utilizan el gestor de trabajo. El administrador enlaza cada uno de los gestores de trabajos con una ubicacin exclusiva en JNDI (Java Naming and Directory Interface). Puede utilizar los objetos de gestor de trabajo en cualquiera de las interfaces siguientes: Beans asncronos Gestor de trabajo CommonJ (si desea ms informacin, consulte el apartado de gestor de trabajo CommonJ en este artculo). El tipo de interfaz seleccionado se resuelve durante la bsqueda JNDI. El tipo de interfaz es el valor que especifica en ResourceRef, en lugar del tipo de interfaz especificado en el objeto de configuracin. Por ejemplo, puede tener una ResourceRef para cada interfaz por objeto de configuracin, y cada bsqueda de ResourceRef devuelve ese tipo apropiado de instancia. Los gestores de trabajo proporcionan un modelo de programacin para las aplicaciones J2EE 1.4. Si desea ms informacin, consulte el apartado sobre el modelo de programacin en este artculo. Cuando graba un componente Web o EJB que utiliza beans asncronos, el desarrollador debera incluir una referencia de recursos en cada componente que necesite acceso a un gestor de trabajos. Si desea ms informacin sobre las referencias de recursos, consulte el artculo Referencias. El componente consulta un gestor de trabajos utilizando un nombre lgico en el componente, espacio de nombres java:comp, del mismo modo que consulta un origen de datos, un enterprise bean o una fbrica de conexiones. El desplegador enlaza los gestores de trabajos fsicos con los gestores de trabajos lgicos cuando se despliega la aplicacin. Por ejemplo, si un desarrollador necesita tres agrupaciones de hebras para particionar el trabajo en los niveles bronce, plata y oro, el desarrollador graba el componente para que elija una agrupacin lgica a partir de un atributo del perfil de la aplicacin cliente. El desplegador tiene flexibilidad para decidir cmo desea correlacionar esta peticin para tres agrupaciones de hebras. El desplegador puede decidir utilizar una sola agrupacin de hebras en una mquina pequea. En este caso, el desplegador enlaza las tres referencias de recursos con la misma instancia de gestor de trabajos (esto es, el mismo nombre JNDI). Una mquina ms potente permite tres agrupaciones de hebras, por lo que el desplegador enlaza cada referencia de recursos con un gestor de trabajo diferente. Los gestores de trabajo se pueden compartir entre varias aplicaciones J2EE instaladas en el mismo servidor. Un desarrollador de aplicaciones puede utilizar tantos gestores de trabajo lgicos como sea necesario. El desplegador elige si desea correlacionar uno o varios gestores de trabajo fsicos con el gestor de trabajo lgico definido en la aplicacin. Todos los componentes J2EE que necesiten compartir objetos de mbito asncrono deben utilizar el mismo gestor de trabajo. Estos objetos de mbito tienen afinidad con un nico gestor de trabajo. Una aplicacin que utilice mbitos asncronos debe verificar que todos los componentes que utilicen objetos de mbito utilizan el mismo gestor de trabajo. Cuando se definen varios gestores de trabajo, las agrupaciones de hebras subyacentes se crean en una JVM (Java Virtual Machine) slo si una aplicacin dentro de esa JVM busca el gestor de trabajo. Por ejemplo, puede que haya definidas diez agrupaciones de hebras (gestores de trabajo), pero en realidad no se crea ninguna hasta que la aplicacin las busca. Nota: los beans asncronos no dan soporte al envo de trabajo a las JVM remotas.

Gestor de trabajo CommonJ

El gestor de trabajo CommonJ es parecido al gestor de trabajo. La diferencia entre los dos estriba en que el gestor de trabajo CommonJ contiene un subconjunto de los mtodos de gestor de trabajo de los beans asncronos. Aunque el gestor de trabajo CommonJ funciona en un entorno J2EE 1.4, la interfaz no devuelve una instancia nueva para cada bsqueda de denominacin JNDI, puesto que esta especificacin no est incluida en la especificacin J2EE. Inicio remoto de trabajo. La funcin opcional de especificacin de trabajo CommonJ para trabajar de forma remota no recibe soporte. Aunque una unidad de trabajo implemente la interfaz java.io.Serializable, la unidad de trabajo no se ejecuta de forma remota.

Cmo buscar un gestor de trabajo

Una aplicacin puede buscar un gestor de trabajo de la siguiente manera. En este ejemplo, el componente contiene una referencia de recursos llamada wm/myWorkManager, que se ha enlazado con un gestor de trabajo fsico cuando se despleg el componente: InitialContext ic = new InitialContext(); WorkManager wm = (WorkManager)ic.lookup("java:comp/env/wm/myWorkManager");

Contextos J2EE de herencia

Los beans asncronos pueden heredar los siguientes contextos. Contexto de internacionalizacin Cuando se selecciona esta opcin y se habilita el servicio de internacionalizacin, y el contexto de internacionalizacin que existe en la hebra de planificacin est disponible en la hebra de destino. rea de trabajo Cuando se selecciona esta opcin, el contexto del rea de trabajo de cada particin de rea de trabajo que existe en la hebra de planificacin est disponible en la hebra de destino. Perfil de aplicacin (en desuso) El contexto del perfil de aplicacin no est soportado y no est disponible para las aplicaciones J2EE 1.4. Para aplicaciones J2EE 1.3, cuando se selecciona esta opcin, se habilita el servicio de perfil de aplicaciones y se selecciona la propiedad de servicio de perfil de aplicaciones modalidad de compatibilidad de 5.x. La tarea de perfil de aplicaciones asociada con la hebra de planificacin est disponible en la hebra de destino para aplicaciones J2EE 1.3. En el caso de aplicaciones J2EE 1.4, la tarea de perfil de aplicaciones es una propiedad de su unidad de trabajo asociada en lugar de una hebra. Esta opcin no afecta al comportamiento de la tarea en aplicaciones J2EE 1.4. El trabajo planificado que se ejecuta en una aplicacin J2EE 1.4 no recibe la tarea de perfilado de aplicaciones de la hebra de planificacin. Seguridad El bean asncrono se puede ejecutar de forma asncrona o como el cliente autenticado en la hebra que lo ha creado. Este comportamiento es de gran utilidad, ya que el bean asncrono puede hacer slo lo que haga el emisor. Esta accin es ms til que un mecanismo RUN_AS, por ejemplo, que impide este tipo de comportamiento. Cuando se selecciona la opcin Seguridad, el sujeto JAAS que existe en la hebra de planificacin est disponible en la hebra de destino. Si no se selecciona, la hebra se ejecuta de forma annima. Metadatos del componente Los metadatos del componente son slo relevantes cuando el bean asncrono es un objeto Java simple. Si el bean es un componente J2EE, por ejemplo, un enterprise bean, los metadatos del componente se activan. Los contextos que se pueden heredar dependen del gestor de trabajo utilizado por la aplicacin que crea el bean asncrono. Con la consola administrativa, el administrador define la poltica de contexto adhesivo de un gestor de trabajo seleccionando los servidos en los que estar disponible el gestor de trabajo.

Modelo de programacin
Los gestores de trabajo dan soporte a los modelos de programacin siguientes. Especificacin CommonJ. El modelo de programacin CommonJ de Application Server versin 6.0 utiliza el gestor de trabajo y el gestor de temporizadores para gestionar hebras y temporizadores de forma asncrona en el entorno J2EE 1.4. Extensiones de especificacin CommonJ y beans asncronos. Las interfaces actuales de beans asncronos EventSource, mbitos asncronos, monitores de subsistemas y J2EEContext son parte de la extensin CommonJ. La tabla siguiente describe el mtodo de correlacin entre las API de CommonJ y beans asncronos. Puede cambiar las interfaces actuales de beans asncronos para utilizar la interfaz CommonJ, al tiempo que conserva las mismas funciones. Paquete de CommonJ Gestor de trabajo Beans asncronos Campo - IMMEDIATE (largo) Campo - INDEFINITE schedule(Work) throws WorkException, IllegalArgumentExcepti on API Paquete de beans asncronos Gestor de trabajo Campo - IMMEDIATE (int) Campo - INDEFINITE startWork(Work) throws WorkException, IllegalArgumentExcep tion startWork(Work, timeout_ms, WorkListener) throws WorkException, IllegalArgumentExcep tion API

schedule(Work, WorkListener) throws WorkException, IllegalArgumentExcepti on Nota: Configure la propiedad de tiempo de espera del gestor de trabajo en el valor que ha especificado previamente en timeout_ms en startWork. El valor por omisin del tiempo de espera es INDEFINITE. waitForAll(workItems, timeout_ms)

join(workItems, JOIN_AND, timeout_ms) join(workItems, JOIN_OR, timeout_ms) WorkItem

waitForAny(workItems, timeout_ms)

WorkItem

getResult getStatus WorkListener workAccepted(WorkEve nt) workCompleted(WorkE vent) workRejected(WorkEve nt) workStarted(WorkEvent ) WorkEvent Campo WORK_ACCEPTED Campo WORK_COMPLETED WorkEvent WorkListener

getResult getStatus

workAccepted(WorkE vent) workCompleted(Work Event) workRejected(WorkE vent) workStarted(WorkEve nt)

Campo WORK_ACCEPTED Campo WORK_COMPLETE D Campo WORK_REJECTED Campo WORK_STARTED getException getType getWork

Campo WORK_REJECTED Campo WORK_STARTED getException getType getWorkItem().getResul t() Nota: Esta API slo es vlida una vez completado el trabajo. Work (extends Runnable) isDaemon release RemoteWorkItem No en este release. Utilice el gestor de NA Work

(Extends Runnable) * release

trabajo distribuido en Extended Deployment o release futuro TimerManager resume schedule(Listener, Date) AlarmManager * create(Listener, context, time) ** es necesario convertir los parmetros

schedule(Listener, Date, period) schedule(Listener, delay, period) scheduleAtFixedRate(Li stener, Date, period) scheduleAtFixedRate(Li stener, delay, period) stop suspend Timer cancel getPeriod getTimerListener scheduledExecutionTim e TimerListener timerExpired(timer) StopTimerListener timerStop(timer) CancelTimerListene r No se aplica No se aplica AlarmListener fired(alarm) getAlarmListener Alarm cancel

timerCancel(timer) WorkException (Extends Exception) WorkException (Extends WsException) (Extends WorkException) (Extends WorkException)

WorkCompletedExc eption WorkRejectedExcep tion

(Extends WorkException) (Extends WorkException)

WorkCompletedExc eption WorkRejectedExcep tion

Si desea ms informacin sobre las API del gestor de trabajo, consulte el Javadoc.

Ejemplo
Tabla 1. Buscar gestor de trabajo Beans asncronos InitialContext ctx = new InitialContext(); com.ibm.websphere.asynchbeans.WorkMan ager wm = (com.ibm.websphere.asynchbeans.WorkMa nager) ctx.lookup(java:comp/env/wm/MyWorkMg r); Tabla 2. Crear el trabajo mediante MyWork Beans asncronos public class MyWork implements com.ibm.websphere.asynchbeans.Work { public void release() { ...... } public void run() { System.out.println(Running.....); } CommonJ public class MyWork implements commonj.work.Work{ public boolean isDaemon() { return false; } public void release () { ..... } public void run () { System.out.println(Running.....); } Tabla 3. Enviar el trabajo Beans asncronos MyWork work1 = new MyWork(new URI = http://www.example./com/1); MyWork work2 = new MyWork(new URI = http://www.example./com/2); CommonJ MyWork work1 = new MyWork(new URI = http://www.example./com/1); MyWork work2 = new MyWork(new URI = http://www.example./com/2); CommonJ InitialContext ctx = new InitialContext(); commonj.work.WorkManager wm = (commonj.work.WorkManager) ctx.lookup(java:comp/env/wm/MyWork Mgr);

WorkItem item1; WorkItem item2; Item1=wm.startWork(work1); Item2=wm.startWork(work2); // caso 1: bloquear hasta que se hayan completado todos los elementos ArrayList col1 = new ArrayList(); Col1.add(item1); Col1.add(item2); wm.join(col1, WorkManager.JOIN_AND, (long)WorkManager.IMMEDIATE); // una vez completados los trabajos System.out.println(work1 data=+work1.getData()); System.out.println(work2 data=+work2.getData()); // caso 2: esperar a que se completen todos los elementos Boolean ret = wm.join(col1, WorkManager.JOIN_OR, 1000);

WorkItem item1; WorkItem item2; Item1=wm.schedule(work1 ); Item2=wm.schedule(work2); // caso 1: bloquear hasta que se hayan completado todos los elementos Collection col1 = new ArrayList(); col1.add(item1); col1.add(item2); wm.waitForAll(col1, WorkManager.IMMEDIATE); // una vez completados los trabajos System.out.println(work1 data=+work1.getData()); System.out.println(work2 data=+work2.getData()); // caso 2: esperar a que se completen todos los elementos Collection finished = wm.waitForAny(col1, 1000); // comprobar el estado de workItems if (finished != null) { Iterator I = finished.iterator(); if (i.hasNext()) { WorkItem wi = (WorkItem) i.next(); if (wi.equals(item1)) { System.out.println(work1 = } else if (wi.equals(item2)) { System.out.println(work1 = } } }

+ work1

+ work

Tabla 4. Crear un gestor de temporizadores Beans asncronos InitialContext ctx = new InitialContext(); com.ibm.websphere.asynchbeans .WorkManager wm = (com.ibm.websphere.asynchbeans.WorkMa nager) ctx.lookup(java:comp/env/wm/MyWorkMg CommonJ InitialContext ctx = new InitialContext(); Commonj.timers.TimerManager tm = (commonj.timers.TimerManager) ctx.lookup(java:comp/env/tm/MyTime rManager);

r); AsynchScope ascope; Try { Ascope = wm.createAsynchScope(ABScope); } Catch (DuplicateKeyException ex) { Ascope = wm.findAsynchScope(ABScope); ex.printStackTrace(); } // obtener un AlarmManager AlarmManager aMgr= ascope.getAlarmManager(); Tabla 5. Activar el temporizador Beans asncronos // crear una alarma ABAlarmListener listener = new ABAlarmListener(); Alarm am = aMgr.create(listener, SomeContext, 1000*60); CommonJ // crear un temporizador TimerListener listener = new StockQuoteTimerListener(qqq, johndoe@example.com); Timer timer = tm.schedule(listener, 1000*60); // Retardo fijo: programar temporizador para que caduque // a los 60 segundos a partir de entonces y repetir cada hora // en lo sucesivo. Timer timer = tm.schedule(listener, 1000*60, 1000*30); // Retardo fijo: programar temporizador para que caduque // a los 60 segundos a partir de entonces y repetir cada hora // en lo sucesivo Timer timer = tm.scheduleAtFixedRate(listener, 1000*60, 1000*30);

Usuarios y privilegios en Oracle

1. Crear Usuarios y asignar privilegios en Oracle El siguiente es un resumen de algunas consideraciones al momento de crear un usuario o cuenta en Oracle, y los privilegios y roles que le podemos asignar.

El nombre de usuario no debe superar 30 caracteres, no debe tener caracteres especiales y debe iniciar con una letra. Un mtodo de autentificacin. El mas comn es una clave o password, pero Oracle 10g soporta otros mtodos (como biometric, certificado y autentificacin por medio de token). Un Tablespace default, el cual es donde el usuario va a poder crear sus objetos por defecto, sin embargo, esto no significa que pueda crear objetos, o que tenga una cuota de espacio. Estos permisos se asignan de forma separada, salvo si utiliza el privilegio RESOURCE el que asigna una quota unlimited, incluso en el Tablespace SYSTEM! Sin embargo si esto ocurre, ud. puede posteriormente mover los objetos creados en el SYSTEM a otro Tablespace. Un Tablespace temporal, donde el usuario crea sus objetos temporales y hace los sort u ordenamientos. Un perfil o profile de usuario, que son las restricciones que puede tener su cuenta (opcional).

Por ejemplo, conectado como el usuario SYS, creamos un usuario y su clave asi: SQL> CREATE USER ahernandez IDENTIFIED BY ahz DEFAULT TABLESPACE users; Si no se indica un Tablespace, por defecto el usuario toma el que est definido en la BD (generalmente el SYSTEM). Para modificar el Tablespace default de un usuario se hace de la siguiente manera: SQL> ALTER USER jperez DEFAULT TABLESPACE datos; Tambin podemos asignar a los usuarios un Tablespace temporal donde se almacenan operaciones de ordenamiento. Estas incluyen las clusulas ORDER BY, GROUP BY, SELECT DISTINCT, MERGE JOIN, o CREATE INDEX (tambin es utilizado cuando se crean Tablas temporales). SQL> CREATE USER jperez IDENTIFIED BY jpz DEFAULT TABLESPACE users TEMPORARY TABLESPACE temp; Adicionalmente, a cada usuario se puede asignar a un profile o perfil, que tiene dos propsitos principalmente:

Limita el uso de recursos, lo que es recomendable, por ejemplo en ambientes de Desarrollo Garantiza y refuerza reglas de Seguridad a nivel de cuentas

Ejemplos, cuando se crea el usuario o asignar un perfil existente: SQL> CREATE USER jperez IDENTIFIED BY jpz DEFAULT TABLESPACE users TEMPORARY TABLESPACE temp PROFILE resource_profile;

SQL> ALTER USER jperez PROFILE perfil_desa; 2. Eliminar un Usuario de la Base de Datos Para eliminar un usuario de la BD se hace uso de la clausula DROP USER y opcionalmente se puede utilizar CASCADE, para decirle que tambin elimine todos los objetos creados por ese usuario. SQL> DROP USER jperez CASCADE; 3. Modificar cuentas de Usuarios Para modificar un usuario creado, por ejemplo cambiar su clave, tenemos la sintxis: SQL> ALTER USER NOMBRE_USUARIO IDENTIFIED BY CLAVE_ACCESO [DEFAULT TABLESPACE ESPACIO_TABLA] [TEMPORARY TABLESPACE ESPACIO_TABLA] [QUOTA {ENTERO {K | M } | UNLIMITED } ON ESPACIO_TABLA [PROFILE PERFIL]; 4. Privilegios de Sistema y de Objetos En Oracle existen dos tipos de privilegios de usuario. 4.1 System: Que permite al usuario hacer ciertas tareas sobre la BD, como por ejemplo crear un Tablespace. Estos permisos son otorgados por el administrador o por alguien que haya recibido el permiso para administrar ese tipo de privilegio. Existen como 100 tipos distintos de privilegios de este tipo. En general los permisos de sistema, permiten ejecutar comandos del tipo DDL (Data definition Language), como CREATE, ALTER y DROP o del tipo DML (Data Manipulation Language). Oracle 10g tiene mas de 170 privilegios de sistema los cuales pueden ser vistos consultando la vista: SYSTEM_PRIVILEGE_MAP Entre todos los privilegios de sistema que existen, hay dos que son los importantes: SYSDBA y SYSOPER. Estos son dados a otros usuarios que sern administradores de base de datos. Para otorgar varios permisos a la vez, se hace de la siguiente manera: SQL> GRANT CREATE USER, ALTER USER, DROP USER TO ahernandez; 4.2 Object: Este tipo de permiso le permite al usuario realizar ciertas acciones en objetos de la BD, como una Tabla, Vista, un Procedure o Funcin, etc. Si a un usuario no se le dan estos permisos slo puede acceder a sus propios objetos (vase USER_OBJECTS). Este tipo de permisos los da el owner o dueo del objeto, el administrador o alguien que haya recibido este permiso explcitamente (con Grant Option). Por ejemplo, para otorgar permisos a una tabla Ventas para un usuario particular:

SQL> GRANT SELECT,INSERT,UPDATE, ON analista.venta TO jperez; Adicionalmente, podemos restringir los DML a una columna de la tabla mencionada. Si quisieramos que este usuario pueda dar permisos sobre la tabla Factura a otros usuarios, utilizamos la clusula WITH GRANT OPTION. Ejemplo: SQL> GRANT SELECT,INSERT,UPDATE,DELETE ON venta TO mgarcia WITH GRANT OPTION; 5. Asignar cuotas a Usuarios Por defecto ningun usuario tiene cuota en los Tablespaces y se tienen tres opciones para poder proveer a un usuario de una quota: 5.1Sin limite, que permite al usuario usar todo el espacio disponible de un Tablespace. 5.2 Por medio de un valor, que puede ser en kilobytes o megabytes que el usuario puede usar. Este valor puede ser mayor o nenor que el tamao del Tablespace asignado a l. 5.3 Por medio del privilegio UNLIMITED TABLESPACE, se tiene prioridad sobre cualquier cuota dada en un Tablespace por lo que tienen disponibilidad de todo el espacio incluyendo en SYSTEM y SYSAUX. No se recomienda dar cuotas a los usuarios en los Tablespaces SYSTEM y SYSAUX, pues tipicamente slo los usuarios SYS y SYSTEM pueden crear objetos en stos. Tampoco dar cuotas en los Tablespaces Temporal o del tipo Undo. 6. Roles Finalmente los Roles, que son simplemente un conjunto de privilegios que se pueden otorgar a un usuario o a otro Rol. De esa forma se simplifica el trabajo del DBA en esta tarea. Por default cuando creamos un usuario desde el Enterprise Manager se le asigna el permiso de connect, lo que permite al usuario conectarse a la BD y crear sus propios objetos en su propio esquema. De otra manera, debemos asignarlos en forma manual. Para crear un Rol y asignarlo a un usuario se hace de la siguiente manera: SQL> CREATE ROLE appl_dba; Opcionalmente, se puede asignar una clave al Rol: SQL> SET ROLE appl_dba IDENTIFIED BY app_pwd; Para asignar este Rol a un usuario: SQL> GRANT appl_dba TO jperez; Otro uso comn de los roles es asignarles privilegios a nivel de Objetos, por ejemplo en una Tabla de Facturas en donde slo queremos que se puedan hacer Querys e Inserts: SQL> CREATE ROLE consulta;

SQL> GRANT SELECT,INSERT on analista.factura TO consulta; Y finalmente asignamos ese rol con este perfil a distintos usuarios finales: SQL> GRANT consulta TO ahernandez; Nota: Existen algunos roles predefinidos, tales como: CONNECT, CREATE SESSION, CREATE TABLE, CREATE VIEW, CREATE SYNONYM, CREATE SEQUENCE, CREATE DATABASE LINK, CREATE CLUSTER, ALTER SESSION, RESOURCE, CREATE PROCEDURE, CREATE SEQUENCE, CREATE TRIGGER, CREATE TYPE, CREATE CLUSTER, CREATE INDEXTYPE, CREATE OPERATOR SCHEDULER, CREATE ANY JOB, CREATE JOB, EXECUTE ANY CLASS, EXECUTE ANY PROGRAM, MANAGE SCHEDULER, etc. DBA: Tiene la mayora de los privilegios, no es recomendable asignarlo a usuarios que no son administradores. SELECT_CATALOG_ROLE: No tiene privilegios de sistema, pero tiene cerca de 1600 privilegios de objeto. Para consultar los roles definidos y los privilegios otorgados a travs de ellos, utilize las vistas: SQL> select * from DBA_ROLES; SQL> select * from DBA_ROLE_PRIVS order by GRANTEE;

Cmo crear un nuevo esquema en Oracle paso a paso

Submitted by cfb on 22 October, 2006 - 21:44

Bases de datos Administracin Bases de datos Oracle create DBA esquema owner tablespace usuario

Versin para impresin Vamos a ver en tres sencillos pasos cmo crear un nuevo esquema-usuario de Oracle. Para poder realizar estos pasos es necesario iniciar la sesin en la base de datos con un usuario con permisos de administracin, lo ms sencillo es utilizar directamente el usuario SYSTEM:

Creacin de un tablespace para datos y otro para ndices. Estos tablespaces son la ubicacin donde se almacenarn los objetos del esquema que vamos a crear.

Tablespace para datos, con tamao inicial de 1024 Mb, y auto extensible CREATE TABLESPACE "APPDAT" LOGGING DATAFILE '/export/home/oracle/oradata/datafiles/APPDAT.dbf' SIZE 1024M EXTENT MANAGEMENT LOCAL SEGMENT SPACE MANAGEMENT AUTO Tablespace para ndices, con tamao inicial de 512 Mb, y auto extensible CREATE TABLESPACE "APPIDX" LOGGING DATAFILE '/export/home/oracle/oradata/datafiles/APPIDX.dbf' SIZE 512M EXTENT MANAGEMENT LOCAL SEGMENT SPACE MANAGEMENT AUTO La creacin de estos tablespaces no es obligatoria, pero s recomendable, as cada usuario de la BD tendr su propio espacio de datos.

Creacin del usuario que va a trabajar sobre estos tablespaces, y que ser el propietario de los objetos que se se creen en ellos

CREATE USER "APP" PROFILE "DEFAULT" IDENTIFIED BY "APPPWD" DEFAULT TABLESPACE "APPDAT" TEMPORARY TABLESPACE "TEMP" ACCOUNT UNLOCK; Si no se especifica un tablespace, la BD le asignar el tablespace USERS, que es el tablespace que se utiliza por defecto para los nuevos usuarios. Se puede apreciar tambin que no hay ninguna referencia al tablespace de ndices APPIDX que hemos creado. Si queremos mantener datos e ndices separados habr que acordarse de especificar este tablespace en las sentencias de creacin de ndices de este usuario, si no se hace stos se crearn en APPDAT: CREATE INDEX mi_indice ON mi_tabla(mi_campo) TABLESPACE APPIDX;

Slo falta asignarle los permisos necesarios para trabajar. Si se le asignan los roles 'Connect' y 'Resource' ya tiene los permisos mnimos, podr conectarse y poder realizar las operaciones ms habituales de consulta, modificacin y creacin de objetos en su propio esquema.

GRANT "CONNECT" TO "APP"; GRANT "RESOURCE" TO "APP"; Completamos la asignacin de permisos con privilegios especficos sobre objetos para asegurarnos de que el usuario pueda realizar todas las operaciones que creamos necesarias GRANT ALTER ANY INDEX TO "APP"; GRANT ALTER ANY SEQUENCE TO "APP"; GRANT ALTER ANY TABLE TO "APP"; GRANT ALTER ANY TRIGGER TO "APP";

GRANT CREATE ANY INDEX TO "APP"; GRANT CREATE ANY SEQUENCE TO "APP"; GRANT CREATE ANY SYNONYM TO "APP"; GRANT CREATE ANY TABLE TO "APP"; GRANT CREATE ANY TRIGGER TO "APP"; GRANT CREATE ANY VIEW TO "APP"; GRANT CREATE PROCEDURE TO "APP"; GRANT CREATE PUBLIC SYNONYM TO "APP"; GRANT CREATE TRIGGER TO "APP"; GRANT CREATE VIEW TO "APP"; GRANT DELETE ANY TABLE TO "APP"; GRANT DROP ANY INDEX TO "APP"; GRANT DROP ANY SEQUENCE TO "APP"; GRANT DROP ANY TABLE TO "APP"; GRANT DROP ANY TRIGGER TO "APP"; GRANT DROP ANY VIEW TO "APP"; GRANT INSERT ANY TABLE TO "APP"; GRANT QUERY REWRITE TO "APP"; GRANT SELECT ANY TABLE TO "APP"; GRANT UNLIMITED TABLESPACE TO "APP"; Ahora el usuario ya puede conectarse y comenzar a trabajar sobre su esquema